दिलचस्प पोस्ट
जावा स्ट्रीम को 1 और केवल 1 तत्व फ़िल्टर करें सीएसएस का उपयोग करते हुए फिक्स्ड हेडर के साथ स्क्रॉलबल टेबल कैसे बनाया जाए Android.content.res.Resources $ NotFoundException प्राप्त करना: अपवाद तब भी जब संसाधन एंड्रॉइड में मौजूद है बुनियादी PHP और AJAX UIScrollView और प्रतिबंध कैसे JTable में कोशिकाओं केंद्र के लिए Json मणि 'mkmf.rb स्थापित करने में त्रुटि रूबी के लिए हेडर फाइल नहीं मिल सकती' लचीलाशर्क में शार्ड्स और प्रतिकृतियां अजगर का समय कितना सही है? ()? जावा 8 में नक्शा और फ्लैटमैप के तरीकों के बीच अंतर क्या है? त्रुटियाँ: "INSERT EXEC वक्तव्य को नेस्टेड नहीं किया जा सकता।" और "INSERT-EXEC स्टेटमेंट के अंदर रोलबैक स्टेटमेंट का उपयोग नहीं किया जा सकता।" यह कैसे हल करें? OpenSSL कमांड के साथ संगत कुंजी फ़ंक्शन के लिए पासवर्ड? MATLAB parfor के लिए धीमी है – क्या गलत है? Internet Explorer में Mozilla's toSource () विधि को लागू करना Google ऐप स्क्रिप्ट के साथ Google डिस्क में एकाधिक फ़ाइलें अपलोड करना

परिभाषा और एक घोषणा के बीच क्या अंतर है?

दोनों का मतलब मुझे छुटकारा दिलाता है

Solutions Collecting From Web of "परिभाषा और एक घोषणा के बीच क्या अंतर है?"

एक घोषणा एक पहचानकर्ता का परिचय करती है और इसके प्रकार का वर्णन करती है, यह एक प्रकार, वस्तु या कार्य है। एक घोषणा है कि संकलक को उस पहचानकर्ता के संदर्भ को स्वीकार करने की आवश्यकता है। ये घोषणाएं हैं:

extern int bar; extern int g(int, int); double f(int, double); // extern can be omitted for function declarations class foo; // no extern allowed for type declarations 

एक परिभाषा वास्तव में इस पहचानकर्ता को इन्स्तांत करती है / लागू करती है उन संस्थाओं के संदर्भों को लिंक करने के लिए लिंककर्ता की आवश्यकता है ये उपरोक्त घोषणाओं से संबंधित परिभाषाएं हैं:

 int bar; int g(int lhs, int rhs) {return lhs*rhs;} double f(int i, double d) {return i+d;} class foo {}; 

एक परिभाषा का प्रयोग एक घोषणा के स्थान पर किया जा सकता है।

एक पहचानकर्ता को जितनी बार आप चाहते हैं, उतना ही घोषित किया जा सकता है। इस प्रकार, सी और सी ++ में निम्नलिखित कानूनी है:

 double f(int, double); double f(int, double); extern double f(int, double); // the same as the two above extern double f(int, double); 

हालांकि, यह बिल्कुल एक बार परिभाषित किया जाना चाहिए। यदि आप किसी ऐसी चीज़ को परिभाषित करने के लिए भूल जाते हैं जिसे कहीं घोषित और संदर्भित किया गया है, तो लिंकर को यह नहीं पता कि क्या संदर्भों को लिंक करना है और किसी गुम प्रतीकों के बारे में शिकायत करता है। यदि आप एक से अधिक बार कुछ परिभाषित करते हैं, तो लिंकर को यह नहीं पता कि संदर्भों को लिंक करने के लिए कौन- से परिभाषाएं हैं और डुप्लिकेट किए गए प्रतीकों के बारे में शिकायत करते हैं।


बहस के बाद से क्लास घोषणापत्र बनाम बना हुआ है, सी ++ में क्लास की परिभाषा आती है (उत्तर में और अन्य प्रश्नों पर टिप्पणी), मैं सी ++ मानक से एक कोट पेस्ट कर दूँगा।
3.1 / 2 में, सी + 03 03 कहता है:

एक घोषणा एक परिभाषा है, जब तक कि यह […] एक वर्ग नाम घोषणा नहीं है […]

3.1 / 3 तो कुछ उदाहरण देता है उन लोगों के बीच:

 [उदाहरण: [...]
 स्ट्रेट S {int a;  int b;  };  // परिभाषित एस, एस :: ए, और एस :: बी [...]
 संरचना एस;  // घोषित एस
 -उदाहरण उदाहरण

इसे जमा करने के लिए: सी + + मानक struct x; मानता है struct x; एक घोषणापत्र और struct x {}; एक परिभाषा (दूसरे शब्दों में, "अग्रेषण घोषणा" एक मिथ्या नाम है , क्योंकि सी ++ में वर्ग घोषणाओं का कोई अन्य रूप नहीं है।)

लिटब के लिए धन्यवाद (जोहान्स शाऊब) ने अपने एक जवाब में वास्तविक अध्याय और कविता खोद ली।

सी ++ मानक खंड 3.1 से:

एक घोषणा एक अनुवाद यूनिट में नाम दर्ज करती है या पिछले घोषणाओं द्वारा शुरू किए गए नामों के पुनर्वित्त के नामों को प्रस्तुत करता है। एक घोषणा इन नामों की व्याख्या और विशेषताओं को निर्दिष्ट करती है।

अगले अनुच्छेद राज्यों (जोर खान) कि एक घोषणा एक परिभाषा है जब तक …

… यह फ़ंक्शन के शरीर को निर्दिष्ट किए बिना फ़ंक्शन को घोषित करता है

 void sqrt(double); // declares sqrt 

… यह एक वर्ग की परिभाषा के भीतर एक स्थिर सदस्य घोषित करता है

 struct X { int a; // defines a static int b; // declares b }; 

… यह एक वर्ग का नाम घोषित करता है

 class Y; 

… इसमें एक प्रारंभिक कीवर्ड या फ़ंक्शन बॉडी के बिना extern कीवर्ड शामिल हैं

 extern const int i = 0; // defines i extern int j; // declares j extern "C" { void foo(); // declares foo } 

… या एक typedef या कथन using

 typedef long LONG_32; // declares LONG_32 using namespace std; // declares std 

अब एक बड़ी वजह से घोषणा और परिभाषा के बीच के अंतर को समझना महत्वपूर्ण है: एक परिभाषा नियम । सी ++ मानक के खंड 3.2.1 से:

कोई अनुवाद इकाई किसी भी चर, फ़ंक्शन, वर्ग प्रकार, गणन प्रकार, या टेम्पलेट की एक से अधिक परिभाषा में नहीं होगी।

घोषणा "कहीं, वहां मौजूद एक फू"

परिभाषा: "… और यहां यह है!"

सी + + (उनमें से कुछ भी सी में) में दिलचस्प बढ़त के मामले हैं विचार करें

 T t; 

यह परिभाषा या एक घोषणा हो सकती है, जो कि प्रकार T आधार पर है:

 typedef void T(); T t; // declaration of function "t" struct X { T t; // declaration of function "t". }; typedef int T; T t; // definition of object "t". 

सी ++ में, टेम्पलेट का उपयोग करते समय, एक और बढ़त का मामला है।

 template <typename T> struct X { static int member; // declaration }; template<typename T> int X<T>::member; // definition template<> int X<bool>::member; // declaration! 

अंतिम घोषणा एक परिभाषा नहीं थी यह X<bool> के स्थिर सदस्य के स्पष्ट विशेषज्ञता की घोषणा है यह कंपाइलर को बताता है: "अगर X<bool>::member को तत्काल करने की बात आती है, तो प्राथमिक टेम्पलेट से सदस्य की परिभाषा को तत्काल न करें, लेकिन कहीं और की गई परिभाषा का उपयोग करें"। इसे परिभाषा बनाने के लिए, आपको एक प्रारंभकर्ता को आपूर्ति करना होगा

 template<> int X<bool>::member = 1; // definition, belongs into a .cpp file. 

घोषणा

घोषणाएं कंपाइलर को बताती हैं कि एक प्रोग्राम तत्व या नाम मौजूद है। एक घोषणा एक कार्यक्रम में एक या एक से अधिक नाम प्रस्तुत करता है। घोषणा एक कार्यक्रम में एक से अधिक बार हो सकती है। इसलिए, प्रत्येक संकलन इकाई के लिए वर्गों, संरचनाओं, एन्यूमरेटेड प्रकार और अन्य उपयोगकर्ता-परिभाषित प्रकारों को घोषित किया जा सकता है।

परिभाषा

परिभाषाएं निर्दिष्ट करती हैं कि किस कोड या डेटा का वर्णन किया गया है। इसका उपयोग करने से पहले एक नाम को घोषित किया जाना चाहिए

C99 मानक से, 6.7 (5):

एक घोषणा पहचानकर्ताओं के एक समूह के व्याख्या और विशेषताओं को निर्दिष्ट करती है। पहचानकर्ता की परिभाषा उस पहचानकर्ता के लिए एक घोषणा है जो:

  • किसी वस्तु के लिए, उस ऑब्जेक्ट के लिए भंडारण आरक्षित होने का कारण बनता है;
  • फ़ंक्शन के लिए, फ़ंक्शन बॉडी शामिल है;
  • एक गणक स्थिर या टाइप किए गए नाम के लिए, यह पहचानकर्ता की (केवल) घोषणा है।

सी ++ मानक से, 3.1 (2):

एक घोषणा एक परिभाषा है, जब तक कि यह फ़ंक्शन के शरीर को निर्दिष्ट किए बिना फ़ंक्शन घोषित करता है, इसमें एक्सटेन स्पेसिफायर या लिंकेज-स्पेसिफिकेशन शामिल होता है और न ही प्रारंभकर्ता या फ़ंक्शन-बॉडी भी होता है, यह एक घोषित घोषणा में एक स्थिर डेटा सदस्य की घोषणा करता है, यह एक है वर्ग नाम घोषणा, या यह एक टाइप-टाइप घोषणा, एक प्रयोग-घोषणा, या एक प्रयोग-निर्देश

फिर कुछ उदाहरण हैं

तो दिलचस्प (या नहीं, लेकिन मैं इसके द्वारा थोड़ा आश्चर्यचकित हूँ), typedef int myint; C99 में एक परिभाषा है, लेकिन केवल C ++ में एक घोषणा

Wiki.answers.com से:

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

उदाहरण के लिए, निम्नलिखित सभी घोषणाएं हैं:

 extern int a; struct _tagExample { int a; int b; }; int myFunc (int a, int b); 

दूसरी ओर परिभाषा का अर्थ यह है कि घोषणाओं की सभी चीजों के अतिरिक्त, अंतरिक्ष भी स्मृति में आरक्षित है आप "परिभाषा = व्याख्यान + स्पेस आरक्षण" कह सकते हैं निम्नलिखित परिभाषा के उदाहरण हैं:

 int a; int b = 0; int myFunc (int a, int b) { return a + b; } struct _tagExample example; 

उत्तर देखें।

सी + + 11 अपडेट

चूंकि मुझे सी ++ 11 के लिए उचित उत्तर नहीं मिल रहा है, यहां एक है।

एक घोषणा एक परिभाषा है, जब तक कि यह एक / n की घोषणा नहीं करती है:

  • अपारदर्शी enum – enum X : int;
  • टेम्पलेट पैरामीटर – template<typename T> class MyArray; में टी template<typename T> class MyArray;
  • पैरामीटर घोषणा – x और y int add(int x, int y);
  • उपनाम घोषणा – using IntVector = std::vector<int>;
  • स्थैतिक जोर घोषणा – static_assert(sizeof(int) == 4, "Yikes!")
  • विशेषता घोषणा (कार्यान्वयन-परिभाषित)
  • खाली घोषणा ;

उपरोक्त सूची से सी ++ 03 से विरासत में मिली अतिरिक्त धाराएं:

  • फ़ंक्शन declaration – int add(int x, int y);
  • एक्सटेन्स स्पेसिफायर जिसमें घोषणा या लिंकेज विनिर्देशक शामिल हैं – extern int a; या extern "C" { ... };
  • एक कक्षा में स्थिर डेटा सदस्य- class C { static int x; }; class C { static int x; };
  • वर्ग / संरचना घोषणा – struct Point;
  • typedef घोषणा – typedef int Int;
  • घोषणा का उपयोग कर – using std::cout;
  • डायरेक्टिव का उपयोग करना – using namespace NS;

एक टेम्प्लेट-घोषणा एक घोषणा है। एक टेम्प्लेट-घोषणा एक परिभाषा भी है यदि इसकी घोषणा एक फ़ंक्शन, एक वर्ग या एक स्थिर डेटा सदस्य को परिभाषित करती है।

उन मानकों के उदाहरण जो घोषणा और परिभाषा के बीच अंतर करते हैं, जिन्हें मैंने उन दोनों के बीच बारीकियों को समझने में सहायक पाया:

 // except one all these are definitions int a; // defines a extern const int c = 1; // defines c int f(int x) { return x + a; } // defines f and defines x struct S { int a; int b; }; // defines S, S::a, and S::b struct X { // defines X int x; // defines non-static data member x static int y; // DECLARES static data member y X(): x(0) { } // defines a constructor of X }; int X::y = 1; // defines X::y enum { up , down }; // defines up and down namespace N { int d; } // defines N and N::d namespace N1 = N; // defines N1 X anX; // defines anX // all these are declarations extern int a; // declares a extern const int c; // declares c int f(int); // declares f struct S; // declares S typedef int Int; // declares Int extern X anotherX; // declares anotherX using N::d; // declares N::d // specific to C++11 - these are not from the standard enum X : int; // declares X with int as the underlying type using IntVector = std::vector<int>; // declares IntVector as an alias to std::vector<int> static_assert(X::y == 1, "Oops!"); // declares a static_assert which can render the program ill-formed or have no effect like an empty declaration, depending on the result of expr template <class T> class C; // declares template class C ; // declares nothing 

परिभाषा का अर्थ है वास्तविक फ़ंक्शनल लिखित और घोषणापत्र का अर्थ है उदा

 void myfunction(); //this is simple declaration 

तथा

 void myfunction() { some statement; } 

यह फ़ंक्शन की मेरी परिभाषा है

घोषणा:

 int a; // this declares the variable 'a' which is of type 'int' 

इस प्रकार घोषणा एक प्रकार के चर को जोड़ती है।

घोषणा के कुछ उदाहरण निम्नलिखित हैं

 int a; float b; double c; 

अब कार्य घोषणा:

 int fun(int a,int b); 

फ़ंक्शन के अंत में अर्धविराम नोट करें, इसलिए यह कहता है कि यह केवल एक घोषणा है। कंपाइलर जानता है कि प्रोग्राम में कहीं कहीं उस फ़ंक्शन को उस प्रोटोटाइप से परिभाषित किया जाएगा। अब अगर कंपाइलर इस तरह कुछ फ़ंक्शन कॉल करता है

 int b=fun(x,y,z); 

कंपाइलर एक त्रुटि बताएगा कि ऐसा कोई फ़ंक्शन नहीं है। क्योंकि उस समारोह के लिए कोई प्रोटोटाइप नहीं है

दो कार्यक्रमों के बीच का अंतर नोट करें

कार्यक्रम 1

 #include <stdio.h> void print(int a) { printf("%d",a); } main() { print(5); } 

इस में, प्रिंट फ़ंक्शन को घोषित और परिभाषित किया गया है। फ़ंक्शन कॉल की परिभाषा के बाद आ रहा है। अब अगले कार्यक्रम देखें

कार्यक्रम 2

  #include <stdio.h> void print(int a); // In this case this is essential main() { print(5); } void print(int a) { printf("%d",a); } 

यह आवश्यक है क्योंकि फ़ंक्शन कॉल की परिभाषा से पहले संकलक को यह पता होना चाहिए कि क्या ऐसा कोई फ़ंक्शन है। इसलिए हम फ़ंक्शन घोषित करते हैं जो कंपाइलर को सूचित करेगा।

परिभाषा:

फ़ंक्शन को परिभाषित करने का यह हिस्सा परिभाषा कहा जाता है यह कहते हैं कि फ़ंक्शन के अंदर क्या करना है।

 void print(int a) { printf("%d",a); } 

अब चर के साथ

 int a; //declaration a=10; //definition 

कभी-कभी घोषणा और परिभाषा को इस तरह से एक बयान में समूहीकृत किया जाता है।

 int a=10; 

क्या आप संभवतः सबसे सामान्य शब्दों में बता सकते हैं, कि एक घोषणा एक पहचानकर्ता है जिसमें कोई भंडारण आवंटित नहीं किया गया है और एक परिभाषा वास्तव में घोषित पहचानकर्ता से भंडारण आवंटित करती है?

एक दिलचस्प विचार – वर्ग या कार्य प्रकार की जानकारी से लिंक होने तक एक टेम्पलेट संग्रहण को आवंटित नहीं कर सकता। तो क्या टेम्पलेट पहचानकर्ता एक घोषणा या परिभाषा है? यह कोई घोषणा नहीं होनी चाहिए क्योंकि कोई भंडारण आवंटित नहीं किया गया है, और आप केवल टेम्पलेट वर्ग या फ़ंक्शन 'प्रोटोटाइप' हैं।

अंगूठे का नियम:

  • एक घोषणा संकलक को बताती है कि मेमोरी में वेरिएबल के डेटा की व्याख्या कैसे करें। यह प्रत्येक पहुंच के लिए आवश्यक है

  • एक परिभाषा में चर मौजूदा बनाने के लिए स्मृति को सुरक्षित रखता है। यह पहली पहुंच से पहले एक बार ठीक होना चाहिए।

इसी तरह के उत्तर यहां मिलें : सी में तकनीकी साक्षात्कार प्रश्न

एक घोषणा कार्यक्रम के लिए एक नाम प्रदान करता है; एक परिभाषा कार्यक्रम के भीतर एक इकाई का एक अद्वितीय वर्णन (उदाहरण के लिए, उदाहरण, और फ़ंक्शन) प्रदान करती है। घोषित किए गए किसी भी क्षेत्र में घोषणाओं को दोहराया जा सकता है, यह किसी दिए गए क्षेत्र में एक नाम का परिचय देता है।

एक घोषणा एक परिभाषा है जब तक कि

  • घोषणा अपने शरीर को निर्दिष्ट किए बिना एक समारोह घोषित करता है,
  • घोषणापत्र में एक बाह्य विनिर्देशक और प्रारंभकर्ता या फ़ंक्शन बॉडी शामिल नहीं है,
  • घोषणापत्र एक स्थिर परिभाषा के बिना एक स्थिर वर्ग डेटा सदस्य की घोषणा है,
  • घोषणा एक वर्ग की परिभाषा है,

परिभाषा एक घोषणा है जब तक कि:

  • परिभाषा एक स्थिर वर्ग डेटा सदस्य को परिभाषित करती है,
  • परिभाषा एक गैर-इनलाइन सदस्य फ़ंक्शन को परिभाषित करती है।

घोषित करने का अर्थ है कि वेरिएबल को नाम और प्रकार दें (चर घोषणापत्र के मामले में) जैसे:

  int i; 

या शरीर के बिना किसी समारोह में नाम, वापसी प्रकार और पैरामीटर (प्रकार) लिखें (फ़ंक्शन घोषणा के मामले में)

उदाहरण के लिए:

 int max(int, int); 

जबकि परिभाषा का मतलब एक चर के लिए मान निर्दिष्ट करना है (चर परिभाषा के मामले में)। उदाहरण के लिए:

 i = 20; 

या एक समारोह में शरीर (कार्यक्षमता) प्रदान / फंक्शन परिभाषा कहा जाता है

उदाहरण के लिए:

  int max(int a, int b) { if(a>b) return a; return b; } 

कई बार घोषणा और परिभाषा एक साथ किया जा सकता है:

 int i=20; 

तथा

 int max(int a, int b) { if(a>b) return a; return b; } 

उपरोक्त मामलों में हम चर I और फ़ंक्शन अधिकतम () को परिभाषित और घोषित करते हैं

यह वास्तव में पनीर को ध्वनि दे रहा है, लेकिन यह सबसे अच्छा तरीका है कि मैं अपने सिर में सीधे शब्दों को रखने में सक्षम हूं:

घोषणा: पिक्चर थॉमस जेफरसन ने एक भाषण दिया … "मुझे यह बताएं कि यह खाना इस स्रोत कोड में मौजूद है !!!"

परिभाषा: एक शब्दकोश की तस्वीर, आप फू को देख रहे हैं और इसका वास्तविक अर्थ क्या है

घोषणा और परिभाषा के बीच अंतर को समझने के लिए हमें विधानसभा कोड देखना होगा:

 uint8_t ui8 = 5; | movb $0x5,-0x45(%rbp) int i = 5; | movl $0x5,-0x3c(%rbp) uint32_t ui32 = 5; | movl $0x5,-0x38(%rbp) uint64_t ui64 = 5; | movq $0x5,-0x10(%rbp) double doub = 5; | movsd 0x328(%rip),%xmm0 # 0x400a20 movsd %xmm0,-0x8(%rbp) 

और यह केवल परिभाषा है:

 ui8 = 5; | movb $0x5,-0x45(%rbp) i = 5; | movl $0x5,-0x3c(%rbp) ui32 = 5; | movl $0x5,-0x38(%rbp) ui64 = 5; | movq $0x5,-0x10(%rbp) doub = 5; | movsd 0x328(%rip),%xmm0 # 0x400a20 movsd %xmm0,-0x8(%rbp) 

जैसा कि आप कुछ भी नहीं बदल सकते हैं

घोषणा परिभाषा से भिन्न है क्योंकि यह केवल कंपाइलर द्वारा उपयोग की जाने वाली सूचना देता है उदाहरण के लिए यूआईटी 8_ टी कंपाइलर को एएसएम फंक्शन movb का इस्तेमाल करने के लिए कहता है।

देखना है कि:

 uint def; | no instructions printf("some stuff..."); | [...] callq 0x400450 <printf@plt> def=5; | movb $0x5,-0x45(%rbp) 

घोषणापत्र एक समकक्ष निर्देश नहीं है क्योंकि यह निष्पादित होने के लिए कुछ नहीं है।

इसके अलावा घोषणा संकलक को चर की गुंजाइश बताती है।

हम कह सकते हैं कि घोषणा एक ऐसी जानकारी है जो संकलक द्वारा उपयोग की जा रही है ताकि वे चर का सही इस्तेमाल कर सकें और कितनी देर तक कुछ स्मृति कुछ चर के अंतर्गत आ सके।

एक घोषणा कार्यक्रम में एक नाम का परिचय देता है; एक परिभाषा एक इकाई का एक अद्वितीय विवरण प्रदान करती है (उदाहरण के लिए, उदाहरण, और फ़ंक्शन)। घोषित घोषणाओं को किसी दिए गए क्षेत्र में दोहराया जा सकता है, यह किसी दिए गए क्षेत्र में एक नाम का परिचय देता है। सी ++ प्रोग्राम में उपयोग किए जाने वाले प्रत्येक ऑब्जेक्ट, फंक्शन या क्लास की एक निश्चित परिभाषा होनी चाहिए। एक घोषणा एक परिभाषा है जब तक कि:

 * it declares a function without specifying its body, * it contains an extern specifier and no initializer or function body, * it is the declaration of a static class data member without a class definition, * it is a class name definition, * it is a typedef declaration. 

परिभाषा एक घोषणा है जब तक कि:

 * it defines a static class data member, * it defines a non-inline member function. 

फ़ंक्शन के साथ घोषित और परिभाषित करने के बीच का अंतर: फ़ंक्शन के लिए प्रोटोटाइप स्टेटमेंट यह घोषित करता है, यानी कम्पाइलर को फ़ंक्शन के बारे में बताता है- उसका नाम, रिटर्न टाइप, और इसके मापदंडों की संख्या और प्रकार। फ़ंक्शन हेडर, फ़ंक्शन के शरीर के बाद, फ़ंक्शन को परिभाषित करता है – फ़ंक्शन ऑपरेशन करने के लिए चरणों का विवरण दे रहा है।

पूर्व।

कोड:

 //Declare int foo(int); //Define int foo(int){ ... } 

चर के सम्मान के साथ: स्वत: और रजिस्टर चर के लिए, परिभाषा और घोषणा के बीच कोई अंतर नहीं है। एक स्वत: या एक रजिस्टर चर घोषित करने की प्रक्रिया चर नाम परिभाषित करती है और उपयुक्त स्मृति आवंटित करती है।

हालांकि, बाहरी चर के लिए: क्योंकि एक चर के लिए मेमोरी केवल एक बार आवंटित की जानी चाहिए, यह सुनिश्चित करने के लिए कि चर का उपयोग हमेशा एक ही सेल से होता है। सभी चर को एक बार और केवल एक बार परिभाषित किया जाना चाहिए।

यदि एक बाहरी चर का उपयोग किसी एक फाइल में किया जाता है जिसमें इसे परिभाषित किया जाता है, तो इसके लिए आवंटित विशिष्ट परिभाषित बाहरी चर सेल के साथ इस तरह के प्रयोग को "कनेक्ट" करने की आवश्यकता है। विभिन्न फ़ाइलों में एक ही बाहरी चर के संदर्भ को जोड़ने की प्रक्रिया को संदर्भों को हल करने के लिए कहा जाता है।

इसे परिभाषित और घोषित किया जा सकता है किसी घोषणा के बिना किसी भी समारोह के बाहर, कोई भंडारण श्रेणी निर्दिष्टकर्ता के साथ। इस तरह की घोषणा चर के लिए स्मृति आवंटित करती है घोषणापत्र की शुरुआत में एक्सटर्न स्टोरेज श्रेणी स्पेसिफ़र के साथ केवल एक वैरिएबल नाम घोषित करने के लिए एक घोषणा कथन का उपयोग किया जा सकता है। ऐसी घोषणा यह निर्दिष्ट करती है कि वेरिएबल कहीं और परिभाषित किया गया है, यानी इस चर के लिए स्मृति अन्य फ़ाइल में आवंटित की गई है। इस प्रकार, एक बाहरी वैरिएबल को एक फ़ाइल के अलावा अन्य में प्रवेश किया जाता है जिसमें यह परिभाषित किया जाता है संभव है कि यह कीवर्ड एक्सटर्न के साथ घोषित किया गया है; कोई नई स्मृति आवंटित नहीं की गई है इस तरह की घोषणा कंपाइलर को बताती है कि वेरिएबल कहीं और परिभाषित किया गया है, और कोड बाहरी वैरिएबल के साथ संकलित किया गया है जिससे अनसुलझे अनियोजित हो गया है। बाहरी चर के संदर्भ को जोड़ने की प्रक्रिया के दौरान हल किया जाता है।

पूर्व।

कोड

 //file1.c extern char stack[10]; extern int stkptr; .... //file2.c char stack[10]; int stkptr; .... 

ये घोषणाएं कंपाइलर को बताती हैं कि चर स्टैक [] और stkptr को कहीं और, आमतौर पर किसी अन्य फ़ाइल में परिभाषित किया जाता है। यदि कीवर्ड एक्सटर्न छोड़े गए थे, तो वेरिएबल को नए माना जाएगा और स्मृति उनके लिए आवंटित की जाएगी। याद रखें, किसी अन्य फ़ाइल में परिभाषित एक ही बाहरी चर तक पहुंच संभव है, यदि कीवर्ड एक्सटर्न को घोषणा में उपयोग किया जाता है

घोषणा और परिभाषा की अवधारणा जब आप बाह्य भंडारण वर्ग का उपयोग कर रहे हैं, तब एक गड़बड़ी बन जाएगी क्योंकि आपकी परिभाषा किसी अन्य स्थान पर होगी और आप अपने स्थानीय कोड फ़ाइल (पेज) में वैरिएबल घोषित कर रहे हैं। सी और सी ++ के बीच एक अंतर यह है कि सी में आप एक फ़ंक्शन या कोड पृष्ठ की शुरुआत में सामान्य रूप से घोषणा कर सकते हैं। सी ++ में ऐसा नहीं है। आप अपनी पसंद के किसी स्थान पर घोषणा कर सकते हैं।

मेरा पसंदीदा उदाहरण "इंट न्यूम = 5" है, यहां आपकी चर 1 है। इंफ 2 के रूप में परिभाषित किया गया। नाम और 3 के रूप में घोषित किया गया। हम

  • किसी ऑब्जेक्ट के प्रकार को परिभाषित करें, जिसे बनाया जा सकता है या एक क्लास या स्ट्रेट
  • किसी वस्तु का नाम घोषित करें, इसलिए किसी नाम के साथ कुछ भी घोषित किया गया है जिसमें वेरिएबल्स, फ़ंक्शन, इत्यादि शामिल हैं।

एक क्लास या स्ट्रक्चर आपको बदलने के लिए अनुमति देता है कि ऑब्जेक्ट को कब परिभाषित किया जाएगा, बाद में इसका उपयोग कब किया जाएगा। उदाहरण के लिए

  • कोई एक विषम वैरिएबल या सरणी को घोषित कर सकता है जो विशेष रूप से परिभाषित नहीं हैं
  • सी + + में एक ऑफ़सेट का उपयोग करके आप उस ऑब्जेक्ट को परिभाषित कर सकते हैं जिसमें कोई घोषित नाम नहीं है।

जब हम प्रोग्रामिंग सीखते हैं तो इन दोनों शब्दों को अक्सर भ्रमित किया जाता है क्योंकि हम अक्सर एक ही समय में दोनों करते हैं।

जब भी हम मुख्य फ़ंक्शन के बाद फ़ंक्शन लिखते हैं, तो संकलक त्रुटि के माध्यम से होगा क्योंकि कॉलिंग फ़ंक्शन के समय फ़ंक्शन के बारे में कोई भी विचार नहीं है। यदि हम फ़ंक्शन के प्रोटोटाइप घोषणापत्र प्रदान करते हैं तो हम संकलक परिभाषा के लिए नहीं देखेंगे।

 int sum(int,int); main() { int res = sum(10,20); } int sum(int n1,int n2) { return(n1+n2); } 

उपरोक्त उदाहरण में, पहली पंक्ति को फ़ंक्शन घोषणा कहा जाता है।

 int sum(int,int); 

वैरिएबल घोषित करना

जब भी हम घोषणा बयान लिखते हैं तो स्मृति को चर के लिए आवंटित नहीं किया जाएगा वैरिएबल घोषणा बेतरतीब ढंग से स्मृति स्थान निर्दिष्ट करेगी।

 int ivar; float fvar; 

वेरिएबल डिक्लेरेशन वीएस डेफिनेशन भेदभाव पैरामीटर

ए अंतरिक्ष आरक्षण:

जब भी हम एक वेरिएबल घोषित करते हैं तो अंतरिक्ष वैरिएबल के लिए आरक्षित नहीं होगा। Whenever we declare a variable then compiler will not look for other details such as definition of the variable.

Declaration is handy way to write code in which actual memory is not allocated.

 struct book { int pages; float price; char *bname; }; 

In the above declaration memory is not allocated. Whenever we define a variable then memory will be allocated for the variable.

 struct book b1; 

B. What it does ?

  1. Declaration will identify the data type of the identifier.
  2. Definition of the variable will assign some value to it.

A declaration presents a symbol name to the compiler. A definition is a declaration that allocates space for the symbol.

 int f(int x); // function declaration (I know f exists) int f(int x) { return 2*x; } // declaration and definition 

A variable is declared when the compiler is informed that a variable exists (and this is its type); it does not allocate the storage for the variable at that point.

A variable is defined when the compiler allocates the storage for the variable.