Fortran
ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग
खोज…
व्युत्पन्न प्रकार परिभाषा
फोरट्रान 2003 ने ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग के लिए समर्थन पेश किया। यह सुविधा आधुनिक प्रोग्रामिंग तकनीकों का लाभ उठाने की अनुमति देती है। व्युत्पन्न प्रकार निम्नलिखित रूप से परिभाषित किए गए हैं:
TYPE [[, attr-list] :: ] name [(name-list)]
[def-stmts]
[PRIVATE statement or SEQUENCE statement]. . .
[component-definition]. . .
[procedure-part]
END TYPE [name]
कहाँ पे,
- Attr-list - विशेषता विनिर्देशकों की एक सूची
- नाम - व्युत्पन्न डेटा प्रकार का नाम
- name-list - अल्पविराम द्वारा अलग प्रकार के पैरामीटर नामों की एक सूची
- def-stmts - नाम-सूची में नाम प्रकार के मापदंडों के एक या एक से अधिक INTEGER घोषणाएं
- घटक-परिभाषा - व्युत्पन्न प्रकार के घटक को परिभाषित करने वाले एक या एक से अधिक प्रकार के घोषणा वक्तव्य या प्रक्रिया सूचक कथन
- प्रक्रिया-भाग - एक कथन बयान, वैकल्पिक रूप से एक निजी बयान के बाद, और एक या एक से अधिक प्रक्रिया बाध्यकारी बयान
उदाहरण:
type shape
integer :: color
end type shape
प्रक्रियाएं लिखें
वर्ग-जैसा व्यवहार प्राप्त करने के लिए, प्रकार और संबंधित प्रक्रियाओं (उप-प्रक्रिया और कार्यों) को एक मॉड्यूल में रखा जाएगा:
उदाहरण:
module MShape
implicit none
private
type, public :: Shape
private
integer :: radius
contains
procedure :: set => shape_set_radius
procedure :: print => shape_print
end type Shape
contains
subroutine shape_set_radius(this, value)
class(Shape), intent(in out) :: self
integer, intent(in) :: value
self%radius = value
end subroutine shape_set_radius
subroutine shape_print(this)
class(Shape), intent(in) :: self
print *, 'Shape: r = ', self%radius
end subroutine shape_print
end module MShape
बाद में, एक कोड में, हम इस आकृति वर्ग का उपयोग इस प्रकार कर सकते हैं:
! declare a variable of type Shape
type(Shape) :: shape
! call the type-bound subroutine
call shape%set(10)
call shape%print
सार व्युत्पन्न प्रकार
एक एक्स्टेंसिबल व्युत्पन्न प्रकार सार हो सकता है
type, abstract :: base_type
end type
इस तरह के व्युत्पन्न प्रकार को कभी भी त्वरित नहीं किया जा सकता है, जैसे कि
type(base_type) t1
allocate(type(base_type) :: t2)
लेकिन एक बहुरूपी वस्तु के पास इसका घोषित प्रकार हो सकता है
class(base_type), allocatable :: t1
या
function f(t1)
class(base_type) t1
end function
सार प्रकार में घटक और प्रकार-बाध्य प्रक्रियाएं हो सकती हैं
type, abstract :: base_type
integer i
contains
procedure func
procedure(func_iface), deferred :: def_func
end type
प्रक्रिया def_func
इंटरफ़ेस func_iface
साथ एक आस्थगित प्रकार-बाध्य प्रक्रिया है। इस तरह की स्थगित प्रकार-बाध्य प्रक्रिया को प्रत्येक विस्तारित प्रकार द्वारा लागू किया जाना चाहिए।
एक्सटेंशन टाइप करें
एक व्युत्पन्न प्रकार एक्स्टेंसिबल है यदि इसमें न तो bind
विशेषता है और न ही sequence
विशेषता है। इस प्रकार को दूसरे प्रकार से बढ़ाया जा सकता है।
module mod
type base_type
integer i
end type base_type
type, extends(base_type) :: higher_type
integer j
end type higher_type
end module mod
घोषित प्रकार के बहुरूपी चर base_type
प्रकार के साथ संगत टाइप है higher_type
और कहा कि गतिशील प्रकार के रूप में हो सकता है
class(base_type), allocatable :: obj
allocate(obj, source=higher_type(1,2))
प्रकार की संगतता बच्चों की एक श्रृंखला के माध्यम से उतरती है, लेकिन एक प्रकार केवल एक अन्य प्रकार का विस्तार कर सकता है।
एक प्रचलित व्युत्पन्न प्रकार माता-पिता से प्रकार की बाध्य प्रक्रियाओं को विरासत में मिला है, लेकिन यह ओवरराइड हो सकता है
module mod
type base_type
contains
procedure :: sub => sub_base
end type base_type
type, extends(base_type) :: higher_type
contains
procedure :: sub => sub_higher
end type higher_type
contains
subroutine sub_base(this)
class(base_type) this
end subroutine sub_base
subroutine sub_higher(this)
class(higher_type) this
end subroutine sub_higher
end module mod
program prog
use mod
class(base_type), allocatable :: obj
obj = base_type()
call obj%sub
obj = higher_type()
call obj%sub
end program
टाइप कंस्ट्रक्टर
कस्टम कन्स्ट्रक्टर्स को टाइप नाम को ओवरलोड करने के लिए इंटरफ़ेस का उपयोग करके व्युत्पन्न प्रकारों के लिए बनाया जा सकता है। इस प्रकार, उस प्रकार के ऑब्जेक्ट का निर्माण करते समय कीवर्ड तर्क जो घटकों के अनुरूप नहीं होते हैं, उनका उपयोग किया जा सकता है।
module ball_mod
implicit none
! only export the derived type, and not any of the
! constructors themselves
private
public :: ball
type :: ball_t
real :: mass
end type ball_t
! Writing an interface overloading 'ball_t' allows us to
! overload the type constructor
interface ball_t
procedure :: new_ball
end interface ball_t
contains
type(ball_t) function new_ball(heavy)
logical, intent(in) :: heavy
if (heavy) then
new_ball%mass = 100
else
new_ball%mass = 1
end if
end function new_ball
end module ball_mod
program test
use ball_mod
implicit none
type(ball_t) :: football
type(ball_t) :: boulder
! sets football%mass to 4.5
football = ball_t(4.5)
! calls 'ball_mod::new_ball'
boulder = ball_t(heavy=.true.)
end program test
इसका उपयोग अलग-अलग इनिशिएटिव रूटीन का उपयोग करने के बजाय एक नट एपीआई बनाने के लिए किया जा सकता है:
subroutine make_heavy_ball(ball)
type(ball_t), intent(inout) :: ball
ball%mass = 100
end subroutine make_heavy_ball
...
call make_heavy_ball(boulder)