के साथ एक सॉल्वर के लिए एक अच्छा ओओपी डिज़ाइन मैं एक पीडीई सिस्टम को हल करने के लिए एक फोरट्रान कोड तैयार कर रहा हूं।आधुनिक फोरट्रान
जिस तरह से यह अभी डिज़ाइन किया गया है यह है कि मेरे पास Variable है जिसमें कई विशेषताएं हैं, जिनमें से सबसे महत्वपूर्ण मूल्य val है जो मान संग्रहीत करता है।
अब मेरे पास solver कक्षा भी है, जो variable पर गणना करेगा। मैंने सोचा कि पूरे variable को सॉल्वर में पास करना और variable%val के साथ काम करना हर बार जब मैं इसे चलाने के लिए (निष्पादन के दौरान कई हज़ार बार) अक्षम होना चाहता हूं, इसलिए मैंने solver कक्षा में पॉइंटर फ़ील्ड को परिभाषित करने का निर्णय लिया उचित चर के लिए हलचल। उदाहरण
program example
use variable
use solvers
type(Variable) T
type(Solver) solver_temperature
!Contructors
call T%create()
call solver_temperature%create(T)
call solver_temperature%solve()
end program example
और solver मॉड्यूल
module solvers
type Solver
real*8, pointer :: T(:,:)
contains
procedure :: create
procedure :: solve
end type
contains
subroutine create(this,T)
type(Solver) :: this
type(Variable) :: T
this%T => T%val
end subroutine
end module
मेरे कार्यक्रम में के लिए मैं विभिन्न भौतिक गुणों और विभिन्न समाधानकर्ताओं कि जिस तरह से मैं ऊपर से पता चला है में उन चर के साथ जुड़े रहे हैं के लिए अलग अलग चर परिभाषित करते हैं।
मैं आम तौर पर ओओपी के लिए नया हूं, इसलिए मेरा सवाल यह है कि यह एक सभ्य डिजाइन है? खासकर एक प्रदर्शन बिंदु से। यह T को केवल एक सरणी बनाने और गति के संदर्भ में एक subroutine solve पर पास करने के साथ तुलना करता है? क्या ऐसा करने का कोई नियमित तरीका है?
मुझे परिवर्तनीय सूचक में बहुत अधिक बिंदु नहीं दिख रहा है। बस इसे एक डमी तर्क के रूप में पास करना मेरे लिए अधिक प्राकृतिक लगता है। यह केवल एक सरणी वर्णनकर्ता है, प्रदर्शन के लिए कुछ भी बुरा नहीं है। –