इंटरफ़ेस करने के लिए एक इकाई जोड़ने से नहीं बल्कि कार्यान्वयन की तुलना में खंड का उपयोग करता खंड

Question

का उपयोग करता है डेल्फी का उपयोग करते समय: मैं एक इकाई की तरह स्थिरांक से भर जाता है कि ...

Unit AConsts; 
Interface 
Const 
    Const1 : WideString = 'Const1'; 
    Const2 : WideString = 'Const2'; 
    Const3 : WideString = 'Const3'; 
    Const4 = 100; 
    Const5 = 100; 
Implementation 
end. 

है और मैं से इस इकाई उपयोग करना चाहते हैं एक और इकाई, वहाँ के बीच ...

Unit AUnit; 
Interface 
Uses 
    AConsts; 
Implementation 
end. 

और

Unit AUnit; 
Interface 
Implementation 
Uses 
    AConsts; 
end. 

कोई अंतर है? या दूसरे शब्दों में, क्या एक संकलित ऐप चिंता के रूप में दोनों के बीच एक अंतर है?

[संपादित करें 1]

जवाब अब तक के लिए धन्यवाद।

मैंने यह प्रश्न पर्याप्त स्पष्ट नहीं किया है, और इसके लिए मैं क्षमा चाहता हूं। यह सवाल गोलाकार संदर्भ आदि से बचने के दायरे के बारे में नहीं है। यह संकलित ऐप में अंतर के बारे में है। शायद एक और उदाहरण मदद करेगा।

यदि यूनिट ए, यूनिटबी और यूनिटसी सभी एकोन्स्ट का उपयोग करते हैं, तो एप 1 के बीच संकलित ऐप (एसीओन्स्ट इकाइयों और अन्य कोड में स्थिरांक के बीच कोई नाम नहीं होने पर) में कोई अंतर होगा, जहां इन यूनिट ए, यूनिटबी और यूनिटसी के पास सभी हैं इंटरफेस सेक्शन में एकोन्स्ट क्लॉज और ऐप 2 का उपयोग करता है जहां यूनिट ए, यूनिटबी और यूनिटसी सभी में कार्यान्वयन अनुभाग के उपयोग खंड में एकोन्स्ट हैं।

Answer 1

अंतर यह है कि आपको AConsts के इंटरफ़ेस अनुभाग में उन चीज़ों का संदर्भ देने की अनुमति है जहां आपको अनुमति है। पहले AUnit में, आप में इंटरफ़ेस अनुभाग में एक निश्चित-आकार सरणी घोषित करने के लिए Const4 का उपयोग कर सकते हैं। आप इसे दूसरे AUnit में नहीं कर सके क्योंकि Const4 दायरे में नहीं है।

संकलित प्रोग्राम पर प्रभाव डाल सकता है, अगर आप सावधान नहीं हैं।मान लीजिए कि हमें एक और इकाई है कि भी एक निरंतर Const4 नामित वाणी है:

unit BConsts; 
interface 
const 
    Const4 = 50; 
implementation 
end. 

अब हम इस तरह UnitA में एक सरणी को परिभाषित:

unit AUnit 
interface 
uses BConsts; 
var 
    data: array[0..Pred(Const4)] of Integer; 
implementation 
uses AConsts; 
procedure Work; 
var 
    i: Integer; 
begin 
    for i := 0 to Const4 - 1 do begin 
    data[i] := 8; 
    end; 
end; 
end. 

कि कोड की समाप्ति के बाद लिखेंगे सरणी क्योंकि Const4 जो इंटरफ़ेस अनुभाग में गुंजाइश है, वह लागू नहीं है Const4 जो कार्यान्वयन अनुभाग में उपयोग किया जाता है। यह अक्सर स्थिरांक के साथ नहीं होता है। यह आमतौर पर केवल दो पहचानकर्ताओं के साथ होता है, FindCloseWindows और SysUtils, और TBitmap में परिभाषित फ़ंक्शन, Graphics और Windows में परिभाषित किया गया है। और उन दो मामलों में, संकलक आपको बताएगा कि आपने कुछ गलत किया है, हालांकि यह आपको ठीक से नहीं बताएगा कि आपने पहचानकर्ता का उपयोग किया है जिसमें दो अलग-अलग अर्थ हैं। आप पहचानकर्ता योग्यता से समस्या का समाधान कर सकते हैं:

for i := 0 to BConsts.Const4 - 1 do 
    data[i] := 8; 

सब से ऊपर सावधानियों को संबोधित कर रहे हैं, तो अपने कार्यक्रम को संकलित करता है और सही ढंग से चलाता है, तो यह कोई फर्क नहीं जहां इकाइयों उपयोग किया जाता है बनाता है। ऐप 1 और ऐप 2 के साथ आपके उदाहरण में, दो कार्यक्रम समान होंगे। वे समान नहीं होंगे - संकलक एक अलग क्रम में चीजों को संसाधित करेगा और इस प्रकार चीजों को अलग-अलग स्थानों पर रखेगा - लेकिन इसका आपके कार्यक्रम के निष्पादन पर कोई प्रभाव नहीं पड़ेगा।

Answer 2

इंटरफ़ेस में उपयोग कथन में आइटम पूरे इकाई में दिखाई दे रहे हैं।

कार्यान्वयन में उपयोग कथन में आइटम केवल लागू अनुभाग में दिखाई दे रहे हैं।

उदाहरण:

unit A; 
interface 
const 
    cA = 1; 
.. 


unit B; 
interface 
const 
    cB = 1; 
.. 



unit C; 
interface 
uses 
    A; 
const 
    cC1 = cA; 
    cC2 = cB; // Error 

implementation 
uses 
    B; 
const 
    cC3 = cA; 
    cC4 = cB; 

end. 

यदि कम से कम एक इकाई कार्यान्वयन खंड में शामिल है आप आपसी निर्भर इकाइयों बना सकते हैं:

unit A; 
interface 
implementation 
uses 
    B; 
end. 


unit B; 
interface 
implementation 
uses 
    A; 
end. 

दोनों इंटरफेस खंड में उपयोग किया जाता है ऐसा नहीं होगा संकलन/लिंक।

Answer 3

आईडीई यह भी उपयोग करता है कि यह संकलन करने की आवश्यकता के बारे में पता लगाने के लिए आप अपने उपयोग कहां घोषित करते हैं।

यदि आपका इंटरफ़ेस अनुभाग यूनिट ए का उपयोग करता है और आपका कार्यान्वयन अनुभाग यूनिटबी का उपयोग करता है, तो यदि यूनिट बी को पुन: सम्मिलित करने की आवश्यकता है, तो आपकी इकाई नहीं होगी, लेकिन यदि इकाई ए बदलती है तो आपकी इकाई को फिर से सम्मिलित करने की आवश्यकता होगी।

यह डेल्फ़िस सुपर फास्ट बिल्ड गति के रहस्यों में से एक है।

आपके पूर्ण निष्पादन योग्य के रूप में, मैं उम्मीद करता हूं कि जहां भी आप घोषणाएं डालते हैं, यह वही आकार बदल जाएगा (लिंकर चालाक है और केवल आपके आवेदन द्वारा उपयोग की जाने वाली विधियों आदि में लिंक), लेकिन वास्तविक स्थान यूनिट घोषणाओं का क्रम बदल दिया गया है, तो विभिन्न स्रोत लगभग निश्चित रूप से बदल जाएंगे।

Answer 4

मैं एक नियम का पालन करता हूं जिसे मैंने इंटरफ़ेस भाग पर सबकुछ रखा है जब तक कि मुझे परिपत्र संदर्भों के साथ समस्याओं का सामना करने की आवश्यकता न हो। यह थोड़ा स्पष्टता लाने में मदद करता है। डेल्फी में कुछ जादूगर और "फ़ाइल> यूनिट का उपयोग करें ..." संवाद ने कार्यान्वयन अनुभाग पर इकाइयों को रखा।

रोब केनेडी पर प्रकाश डालने वाले स्कोपिंग जाल को छोड़कर, इससे कोई फर्क नहीं पड़ता। अपना मानक बनाएं और इसके साथ चिपके रहें।

Answer 5

मैंने कार्यान्वयन अनुभाग में सभी संदर्भ डाले और केवल उन यूनिट नामों को इंटरफ़ेस में रखा जो मुझे करना है।

मुझे जितना संभव हो सके सब कुछ के दायरे को सीमित करना पसंद है, और यह नीति उसके अनुसार है।