Was ist der Unterschied zwischen einer Definition und einer Erklärung?

Question

Die Bedeutung von beidem entzieht sich mir.

Answer 1

Aus dem C99-Standard, 6.7(5):

Eine Deklaration spezifiziert die Interpretation und die Attribute eines Satzes von Identifikatoren. A Definition eines Identifikators ist eine Erklärung für diesen Identifikator, die:

• für ein Objekt, so wird für dieses Objekt Speicherplatz reserviert;
• für eine Funktion, schließt den Funktionsrumpf ein;
• für eine Aufzählungskonstante oder einen Typedef-Namen, ist die (einzige) Deklaration des Bezeichners.

Aus dem C++ Standard, 3.1(2):

Eine Erklärung ist eine Definition es sei denn, sie deklariert eine Funktion ohne Angabe des Funktionskörpers, sie enthält den Spezifizierer extern oder eine Verknüpfungsspezifikation und weder einen Initialisierer noch einen Funktionskörper, sie deklariert ein statisches Datenelement in einer Klassendeklaration, sie ist eine Klassennamendeklaration oder sie ist eine Typedef-Deklaration, eine using-Deklaration oder eine using-Anweisung.

Dann gibt es einige Beispiele.

Interessanterweise (oder auch nicht, aber ich bin etwas überrascht), typedef int myint; ist eine Definition in C99, aber nur eine Deklaration in C++.

Answer 2

Von wiki.answers.com:

Der Begriff Deklaration bedeutet (in C), dass Sie dem Compiler den Typ, die Größe und im Falle einer Funktionsdeklaration den Typ und die Größe der Parameter einer Variablen, eines benutzerdefinierten Typs oder einer Funktion in Ihrem Programm mitteilen. Nein Im Falle einer Deklaration wird für jede Variable Speicherplatz reserviert. Der Compiler weiß jedoch, wie viel Platz zu reservieren ist, wenn eine Variable dieses Typs erstellt wird.

Zum Beispiel sind alle folgenden Erklärungen:

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

Definition hingegen bedeutet, dass zusätzlich zu all dem, was die Deklaration tut, auch Speicherplatz reserviert wird. Man kann sagen: "DEFINITION = DECLARATION + SPACE RESERVATION":

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

siehe Antworten .

Answer 3

C++11 Update

Da ich keine für C++11 relevante Antwort sehe, hier ist eine.

Eine Erklärung ist eine Definition es sei denn, es wird a/n erklärt:

• undurchsichtiges enum - enum X : int;
• Vorlageparameter - T en template<typename T> class MyArray;
• Parameter-Deklaration - x y y en int add(int x, int y);
• Alias-Deklaration - using IntVector = std::vector<int>;
• statische Assert-Deklaration - static_assert(sizeof(int) == 4, "Yikes!")
• Attributdeklaration (implementierungsabhängig)
• leere Erklärung ;

Zusätzliche Klauseln, die von C++03 durch die obige Liste übernommen wurden:

• Funktionsdeklaration - hinzufügen. en int add(int x, int y);
• externer Spezifizierer, der eine Deklaration oder einen Verknüpfungsspezifizierer enthält - extern int a; o extern "C" { ... };
• statisches Datenelement in einer Klasse - x en class C { static int x; };
• Klasse/Struktur-Deklaration - struct Point;
• typedef-Deklaration - typedef int Int;
• Erklärung verwenden - using std::cout;
• Richtlinie verwenden - using namespace NS;

Eine Template-Deklaration ist eine Erklärung. Eine Vorlagen-Deklaration ist auch eine Definition, wenn ihre Deklaration eine Funktion, eine Klasse oder ein statisches Datenelement definiert.

Beispiele aus der Norm, in der zwischen Deklaration und Definition unterschieden wird, die ich für das Verständnis der Nuancen zwischen den beiden hilfreich fand:

// 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

Answer 4

Definition:

extern int a;      // Declaration 
int a;             // Definition
a = 10             // Initialization
int b = 10;        // Definition & Initialization

Bei der Definition wird die Variable mit einem Typ verknüpft und Speicher zugewiesen, während bei der Deklaration nur der Typ angegeben wird, aber kein Speicher zugewiesen wird. Die Deklaration ist sinnvoller, wenn Sie die Variable vor der Definition referenzieren wollen.

*Verwechseln Sie nicht Definition und Initialisierung. Beide sind unterschiedlich, die Initialisierung gibt der Variablen einen Wert. Siehe das obige Beispiel.

Es folgen einige Beispiele für Definitionen.

int a;
float b;
double c;

Jetzt Funktionsdeklaration :

int fun(int a,int b); 

Beachten Sie das Semikolon am Ende der Funktion, das besagt, dass es sich nur um eine Deklaration handelt. Der Compiler weiß, dass die Funktion irgendwo im Programm als definiert mit diesem Prototyp. Wenn der Compiler nun einen Funktionsaufruf wie den folgenden erhält

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

Der Compiler gibt einen Fehler aus, der besagt, dass es eine solche Funktion nicht gibt. Denn es gibt keinen Prototyp für diese Funktion.

Beachten Sie den Unterschied zwischen zwei Programmen.

Programm 1

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

Darin wird auch die Druckfunktion deklariert und definiert. Da der Funktionsaufruf nach der Definition kommt. Sehen Sie sich nun das nächste Programm an.

Programm 2

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

Sie ist unerlässlich, da der Funktionsaufruf der Definition vorausgeht, so dass der Compiler wissen muss, ob es eine solche Funktion gibt. Wir deklarieren also die Funktion, die den Compiler informiert.

Definition:

Dieser Teil der Definition einer Funktion wird als Definition bezeichnet. Er sagt, was innerhalb der Funktion geschehen soll.

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

Answer 5

Um die Substantive zu verstehen, sollten wir uns zunächst auf die Verben konzentrieren.

deklarieren - offiziell ankündigen; verkünden

definieren. - (jemanden oder etwas) klar und vollständig zeigen oder beschreiben

Wenn Sie also etwas deklarieren, sagen Sie einfach was es ist .

// declaration
int sum(int, int);

Diese Linie erklärt eine C-Funktion namens sum die zwei Argumente des Typs int und gibt eine int . Sie können sie jedoch noch nicht verwenden.

Wenn Sie wie es tatsächlich funktioniert Das ist die Definition dafür.

// definition
int sum(int x, int y)
{
    return x + y;
}