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

StackOverflow https://stackoverflow.com/questions/1410563

Frage

Die Bedeutung der beiden entzieht sich mir.

War es hilfreich?

Lösung

A Erklärung stellt einen Identifikator und beschreibt deren Art, sei es eine Art, Objekt oder eine Funktion. Eine Erklärung ist was der Compiler benötigt Verweise auf diese Kennung zu akzeptieren. Dies sind Erklärungen: 

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

Definition tatsächlich instanziiert / implementiert diese Kennung. Es ist , was die Linker Bedürfnisse , um Verweise auf diese Entitäten zu verknüpfen. Dies sind Definitionen entsprechend den obigen Erklärungen: 

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

Eine Definition kann an der Stelle einer Erklärung verwendet werden.

Eine Kennung kann sein erklärt so oft wie Sie wollen. Somit ist die folgende Recht in C und C ++: 

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

Allerdings muss es sein, definiert genau einmal. Wenn Sie vergessen, etwas zu definieren, die irgendwo deklariert und referenziert ist schon, dann der Linker nicht weiß, was Verweise auf verlinken auf und beschwert sich über eine fehlende Symbole. Wenn Sie etwas mehr als einmal definieren, dann der Linker nicht weiß, die der Definitionen Verweise auf verknüpfen und beschwert sich über dupliziert Symbole.

Da die Debatte, was eine Klasse ist Erklärung gegen eine Klasse Definition in C ++ kommen immer wieder (in Antworten und Kommentare zu anderen Fragen), ich werde eine Paste Zitat aus dem C ++ Standard hier.
3.1 / 2, C ++ 03 sagt:

  

Eine Erklärung ist eine Definition, es sei denn, es [...] ist ein Klassenname Erklärung [...].

3,1 / 3 gibt dann einige Beispiele. Unter ihnen: 

[Example: [...]
struct S { int a; int b; }; // defines S, S::a, and S::b [...]
struct S; // declares S
—end example

Um es zusammenzufassen: Die C ++ Standard hält struct x; a Erklärung sein und struct x {}; eine Definition . (Mit anderen Worten: "forward-Deklaration" eine falsche Bezeichnung , da es keine andere Formen der Klassendeklarationen in C ++.)

Danke href="https://stackoverflow.com/users/34509/johannes-schaub-litb"> litb (Johannes Schaub) zum die in einem seiner den eigentlichen Kapitel und Vers ausgegraben Antworten.

Andere Tipps

Aus der C ++ Standard Abschnitt 3.1:

  

A Erklärung führt Namen in eine Übersetzungseinheit oder redeclares Namen von früheren eingeführt   Erklärungen. Eine Erklärung gibt die Interpretation und Attribute dieser Namen.

Der nächste Absatz heißt (Hervorhebung von mir), dass eine Erklärung ist eine Definition , es sei denn ...

... es deklariert eine Funktion ohne die Funktion des Körpers festgelegt wird: 

void sqrt(double);  // declares sqrt

... es deklariert ein statisches Element innerhalb einer Klassendefinition: 

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

... es erklärt einen Klassennamen: 

class Y;

... es enthält das extern Schlüsselwort ohne Initialisierer oder Funktionskörper: 

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

... oder ist eine typedef oder using Aussage. 

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

Jetzt kommt der große Grund, warum es wichtig, den Unterschied zwischen einer Erklärung und Definition zu verstehen: Eine Definition Regel . Aus Abschnitt 3.2.1 des C ++ Standard:

  

Keine Übersetzungseinheit muss folgende Angaben enthalten mehr als eine Definition einer Variablen, Funktion, Klassentyp, Aufzählungstyp oder Vorlage.

Erklärung: "Irgendwo gibt es eine foo"

Definition: "... und hier ist es!"

Es gibt interessante Grenzfälle in C ++ (einige von ihnen in C auch). Betrachten 

T t;

Das kann eine Definition oder eine Erklärung sein, je nachdem, welche Art T ist: 

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".

In C ++, wenn Vorlagen verwenden, gibt es einen weiteren Fall Kante. 

template <typename T>
struct X { 
  static int member; // declaration
};

template<typename T>
int X<T>::member; // definition

template<>
int X<bool>::member; // declaration!

Die letzte Erklärung war nicht eine Definition. Es ist die Deklaration einer expliziten Spezialisierung des statischen Mitglied X<bool>. Es teilt den Compiler: „Wenn es X<bool>::member zu instanziieren kommt, dann nicht die Definition des Elements aus der primären Vorlage instanziiert, aber die Definition an anderer Stelle gefunden verwenden“. Um es eine Definition zu machen, haben Sie einen Initialisierer liefern 

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

Erklärung

  

Erklärungen sagen dem Compiler, dass ein   Programmelement oder Namen existiert. EIN   Erklärung stellt ein oder mehr   Namen in ein Programm. Erklärungen können   tritt mehr als einmal in einem Programm.   Daher Klassen, Strukturen,   Aufzählungstypen und andere   benutzerdefinierte Typen können deklariert werden   jede Übersetzungseinheit.

Definition

  

Definitionen angeben, welchen Code oder Daten   der Name beschreibt. Ein Name muss sein   erklärt, bevor es verwendet werden kann.

Von dem C99-Standard, 6,7 (5):

Eine Deklaration spezifiziert die Auslegung und Attribute aus einem Satz von Identifikatoren. A Definition eine Kennung ist eine Erklärung für diese Kennung, die:

  • für ein Objekt, verursacht Speicher für das Objekt reserviert werden;
  • für eine Funktion, enthält die Funktion Körper;
  • für eine Enumerationskonstante oder typedef Namen, die (nur) Erklärung der Kennung.

Aus der C ++ Standard 3.1 (2):

Eine Erklärung ist ein Definition , wenn es eine Funktion erklärt, ohne die Funktion des Körpers Angabe, es enthält die externen Bezeichner oder eine Verknüpfung-Spezifikation und weder einen initializer noch einen funktions Körper, es ist ein statisches erklärt Datenelement in einer Klassendeklaration, es ist ein Klassenname Erklärung, oder es ist eine typedef Erklärung, eine using-Deklaration oder ein using-Direktive.

Dann gibt es einige Beispiele.

So interessant (oder auch nicht, aber ich bin von etwas überrascht), typedef int myint; ist eine Definition in C99, sondern nur eine Erklärung in C ++.

C ++ 11-Update

Da sehe ich eine Antwort relevant für nicht 11 C ++ ist hier ein.

Eine Erklärung ist eine Definition , wenn es a / n erklärt:

  • undurchsichtige Enum - enum X : int;
  • Template-Parameter - T in template<typename T> class MyArray;
  • Parameterdeklaration - x und y in int add(int x, int y);
  • alias Erklärung - using IntVector = std::vector<int>;
  • statische assert Erklärung - static_assert(sizeof(int) == 4, "Yikes!")
  • Attribut-Deklaration (Implementierung definiert)
  • leere Erklärung ;

Weitere Klauseln geerbt von C ++ 03 von der obigen Liste:

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

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

Beispiele aus dem Standard, der zwischen Erklärung und Definition unterscheidet, die ich in das Verständnis der Nuancen zwischen ihnen nützlich gefunden: 

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

Definition ist die tatsächliche Funktion geschrieben und Deklaration bedeutet einfach declare Funktion für z.B. 

void  myfunction(); //this is simple declaration

und 

void myfunction()
{
 some statement;    
}

Dies ist Definition der Funktion myfunction

Als Faustregel gilt:

  • Erklärung sagt dem Compiler, wie die Variable Daten im Speicher zu interpretieren. Dies wird für jeden Zugriff benötigt wird.

  • Definition behält sich das Speicher die Variable bestehende zu machen. Dies muss genau einmal vorkommen, vor dem ersten Zugriff.

Erklärung: 

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

So Deklaration ordnet die Variable mit einem Typ.

Im Folgenden sind einige Beispiele der Erklärung. 

int a;
float b;
double c;

Funktionsdeklaration: 

int fun(int a,int b);

Beachten Sie das Semikolon am Ende der Funktion, so dass es sagt, es ist nur eine Erklärung. Compiler weiß, dass irgendwo in dem Programm, das wird funktionieren definiert mit diesem Prototyp. Nun, wenn der Compiler bekommt einen Funktionsaufruf so etwas wie diese 

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

Compiler wird ein Fehler werfen sagen, dass es keine solche Funktion ist. Weil es keinen Prototyp hat hat 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);
}

In dieser Druckfunktion deklariert und als gut definiert. Da Funktionsaufruf wird nach der Definition kommen. Nun sehen Sie das nächste Programm.

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);
 }

Es ist wichtig, weil Funktionsaufruf Definition voran so Compiler muss wissen, ob es eine solche Funktion ist. So erklären wir die Funktion, die die Compiler informieren.

Definition:

Dieser Teil eine Funktion definieren, wird Definition bezeichnet. Er sagt, was in der Funktion zu tun. 

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

Jetzt mit den Variablen. 

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

Einige Male Deklaration und Definition sind eine einzige Anweisung wie folgt gruppiert. 

int a=10;

, um die Substantive zu verstehen, lassen Sie uns auf die Verben konzentrieren zuerst.

erklären - zu verkünden offiziell; verkünden

definieren - zu zeigen, oder (jemand oder etwas) klar und vollständig zu beschreiben

Also, wenn Sie etwas zu erklären, die Sie gerade sagen, , was es ist . 

// declaration
int sum(int, int);

Diese Zeile erklärt eine C-Funktion aufgerufen sum die zwei Argumente vom Typ int nimmt und gibt eine int. Aber man kann es noch nicht verwendet werden.

Wenn Sie bieten wie es tatsächlich funktioniert , das ist die Definition davon. 

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

, um den Unterschied zwischen Erklärung zu verstehen und Definition müssen wir den Assembler-Code sehen: 

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)

und dies ist nur Definition: 

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)

Wie Sie nichts ändern sehen.

Erklärung unterscheidet sich von der Definition, da es Informationen nur vom Compiler verwendet gibt. Zum Beispiel uint8_t dem Compiler sagt asm-Funktion MOVB zu verwenden.

Sehen Sie, dass: 

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

Erklärung hat keine entsprechende Anweisung, weil es nicht etwas ausgeführt werden soll.

Außerdem Deklaration teilt der Compiler den Umfang der Variablen.

Wir können sagen, dass diese Erklärung eine Information durch den Compiler zu etablieren, die korrekte Verwendung der Variablen und wie lange einige Speicher gehört zu bestimmten Variablen.

verwendet wird,

Couldnt Sie in den allgemeinsten Begriffen möglich angeben, dass eine Erklärung ist eine Kennung, bei dem kein Speicher zugeordnet ist und eine Definition ordnet tatsächlich Speicher von einem deklarierten Bezeichner?

Ein interessanter Gedanke - eine Vorlage keinen Speicher zuordnen, bis die Klasse oder Funktion mit der Typinformation verknüpft ist. So wird die Vorlage eine Erklärung oder Definition Identifier? Es sollte eine Erklärung sein, da keine Speicherung zugeordnet ist, und Sie sind einfach die Template-Klasse oder Funktion ‚Prototyping‘.

ähnliche Antworten hier: Technisches Interview Fragen in C .

Erklärung bietet einen Namen für das Programm; a Definition bietet eine eindeutige Beschreibung einer Entität (z.B. Typen, beispielsweise und Funktion) innerhalb des Programms. Erklärungen können in einem bestimmten Umfang wiederholt werden, es führt einen Namen in einem bestimmten Bereich.

Eine Erklärung ist eine Definition, es sei denn:

  • Erklärung deklariert eine Funktion ohne seinen Körper Angabe
  • Deklaration enthält einen externen Bezeichner und keine Initialisierer oder Funktionskörper,
  • Erklärung ist die Deklaration eines statischen Klasse Datenelement ohne eine Klassendefinition,
  • Deklaration ist ein Klassenname Definition

Eine Definition ist eine Erklärung, es sei denn:

  • Definition definiert ein statisches Klassendatenelement,
  • Definition definiert eine Nicht-Inline-Elementfunktion.

Das wird wirklich kitschig klingen, aber es ist der beste Weg, ich in der Lage gewesen war, die Bedingungen gerade in meinem Kopf zu halten:

Erklärung: Bild Thomas Jefferson eine Rede ... „Ich erkläre hiermit, dass DIESE FOO IN DIESER QUELLCODE VORHANDEN !!!“

Definition: Bild ein Wörterbuch, Sie suchen nach oben Foo und was es eigentlich bedeutet,

.

Eine Erklärung stellt einen Symbolnamen an den Compiler. Eine Definition ist eine Erklärung, die den Raum für das Symbol zuordnet. 

int f(int x); // function declaration (I know f exists)

int f(int x) { return 2*x; } // declaration and definition

Nach dem GNU-C-Bibliothek Handbuch ( http: / /www.gnu.org/software/libc/manual/html_node/Header-Files.html )

  

In C eine Erklärung lediglich informiert, dass eine Funktion oder Variable existiert und gibt seine Art. Für eine Funktionsdeklaration, Informationen über die Art ihrer Argumente könnten auch zur Verfügung gestellt werden. Der Zweck der Erklärungen ist es, den Compiler zu ermöglichen, richtig Verweise auf die deklarierten Variablen und Funktionen zu verarbeiten. Eine Definition, auf der anderen Seite, weist tatsächlich Speicher für eine Variable oder sagt, was eine Funktion der Fall ist.

Deklaration bedeutet, sind Name und Typ einer Variablen (bei der Variablendeklaration), zB: 

int i;

oder geben Sie Namen, Rückgabetyp und Parameter (n) ohne Körper auf eine Funktion geben (bei der Funktionsdeklaration), zB: 

int max(int, int);

Die Definition bedeutet assign Wert einer Variablen (im Falle der Variablendefinition), zB: 

i = 20;

oder bieten / add Körper (Funktionalität) zu einer Funktion Funktionsdefinition genannt, zum Beispiel: 

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

viele Zeit Erklärung und Definition kann zusammen getan werden: 

int i=20;

und 

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

In diesen Fällen wir definieren und erklären Variable i und function max().

Das Konzept der Erklärung und Definition eine pitfall bilden, wenn Sie die externe Speicherklasse verwenden, weil Ihre Definition in einem anderen Ort sein wird und Du die Variable in Ihrer lokalen Codedatei deklariert (Seite). Ein Unterschied zwischen C und C ++ ist, dass in C Sie die Erklärungen fertig sind normalerweise am Anfang einer Funktion oder Codepage. In C ++ ist es nicht gefallen, dass. Sie können an einem Ort Ihrer Wahl erklären.

Mein Lieblingsbeispiel ist „int Num = 5“ hier Ihre Variable 1. als int 2. als Num erklärt definiert ist und 3 mit einem Wert von fünf instanziiert. Wir

  • Definieren Sie den Typ eines Objekts, das oder einer Klasse oder Struktur in gebaut werden kann.
  • Deklarieren Sie den Namen eines Objekts, so etwas mit einem Namen deklariert wurde, das beinhaltet Variablen, Funtions, etc.

Eine Klasse oder Struktur können Sie ändern, wie Objekte definiert werden, wenn sie später verwendet wird. Zum Beispiel

  • kann man eine heterogene Variable oder Array angeben, die nicht speziell definiert sind.
  • Unter Verwendung einer in C ++ versetzt Sie ein Objekt definieren können, die keinen deklarierten Namen hat.

Wenn wir diese beiden Begriffe lernen Programmierung sind oft verwirrt, weil wir oft beides zugleich.

Die Stufen einer ausführbaren Generation:

  

(1) Vorprozessor -> (2) Übersetzer / Compiler -> (3) Linker

In der Stufe 2 (Übersetzer / Compiler), Deklarationsanweisungen in unserem Code zu dem Compiler sagen, dass diese Dinge, die wir in Zukunft nutzen werden und Sie Definition später finden, Bedeutung ist:

  

Übersetzer stellen Sie sicher, dass: was ist das, was bedeutet Erklärung

und (3) Stufe (Linker) benötigt Definition, die Dinge zu binden

  

Linkers stellen Sie sicher, dass: wo ist das, was bedeutet Definition

Lizenziert unter: CC-BY-SA mit Zuschreibung
Nicht verbunden mit StackOverflow
scroll top