description - title tag bilder




Was ist der Unterschied zwischen einer Definition und einer Deklaration? (17)

C ++ 11 Update

Da ich keine Antwort zu C ++ 11 sehe, hier ist eine.

Eine Deklaration ist eine Definition, es sei denn, sie deklariert a / n:

  • undurchsichtiges Enum - enum X : int;
  • Vorlagenparameter - T in template<typename T> class MyArray;
  • Parameterdeklaration - x und y in int add(int x, int y);
  • Alias-Deklaration - using IntVector = std::vector<int>;
  • Statische static_assert(sizeof(int) == 4, "Yikes!") Deklaration - static_assert(sizeof(int) == 4, "Yikes!")
  • Attributdeklaration (implementierungsdefiniert)
  • leere Deklaration ;

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

  • Funktionsdeklaration - add in int add(int x, int y);
  • externer Spezifizierer, der eine Deklaration oder einen Verknüpfungsspezifizierer enthält - extern int a; oder extern "C" { ... };
  • static data member in einer Klasse - x in class C { static int x; }; class C { static int x; };
  • class / struct-Deklaration - struct Point;
  • typedef-Deklaration - typedef int Int;
  • Deklaration verwenden - using std::cout;
  • Direktive verwenden - using namespace NS;

Eine Template-Deklaration ist eine Deklaration. Eine Vorlagendeklaration ist auch eine Definition, wenn ihre Deklaration eine Funktion, eine Klasse oder ein statisches Datenelement definiert.

Beispiele aus dem Standard, der zwischen Deklaration und Definition unterscheidet, die ich beim Verständnis der Nuancen zwischen ihnen 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

Die Bedeutung von beiden entzieht sich mir.


Aus dem C ++ - Standardabschnitt 3.1:

Eine Deklaration führt Namen in eine Übersetzungseinheit ein oder deklariert Namen neu, die durch frühere Deklarationen eingeführt wurden. Eine Deklaration gibt die Interpretation und Attribute dieser Namen an.

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

... deklariert eine Funktion, ohne den Körper der Funktion anzugeben

void sqrt(double);  // declares sqrt

... es deklariert ein statisches Member innerhalb einer Klassendefinition

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

... es deklariert 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 Anweisung.

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

Jetzt aus dem großen Grund, warum es wichtig ist, den Unterschied zwischen einer Deklaration und einer Definition zu verstehen: die One Definition Rule . Aus Abschnitt 3.2.1 des C ++ - Standards:

Keine Übersetzungseinheit darf mehr als eine Definition einer Variablen, Funktion, eines Klassentyps, eines Aufzählungstyps oder einer Vorlage enthalten.


Aus 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 seiner Parameter einer beliebigen Variablen oder eines benutzerdefinierten Typs oder einer Funktion in Ihrem Programm mitteilen. Bei einer Deklaration ist im Speicher kein Platz für eine Variable reserviert. Der Compiler weiß jedoch, wie viel Speicherplatz reserviert werden muss, falls eine Variable dieses Typs erstellt wird.

Zum Beispiel folgen alle Deklarationen:

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

Definition bedeutet andererseits, dass zusätzlich zu all den Dingen, die diese Deklaration ausführt, auch der Speicherplatz im Speicher reserviert ist. Sie können "DEFINITION = DECLARATION + SPACE RESERVATION" sagen, die folgende Beispiele sind:

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

siehe Answers .


Das wird wirklich kitschig klingen, aber es ist der beste Weg, wie ich die Begriffe im Kopf behalten konnte:

Erklärung: Bild Thomas Jefferson hält eine Rede ... "Ich erkläre hiermit, dass dieser FOO in diesem Quellcode existiert !!!"

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


Eine Deklaration führt einen Bezeichner ein und beschreibt dessen Typ, sei es ein Typ, ein Objekt oder eine Funktion. Eine Deklaration ist, was der Compiler benötigt , um Referenzen auf diesen Bezeichner zu akzeptieren. Dies sind Deklarationen:

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

Eine Definition instanziiert / implementiert diesen Bezeichner tatsächlich. Dies ist, was der Linker benötigt , um Verweise auf diese Entitäten zu verknüpfen. Dies sind Definitionen, die den obigen Erklärungen entsprechen:

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 anstelle einer Deklaration verwendet werden.

Ein Bezeichner kann beliebig oft deklariert werden . Somit ist das Folgende in C und C ++ erlaubt:

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

Es muss jedoch genau einmal definiert werden. Wenn Sie vergessen, etwas zu definieren, das irgendwo deklariert und referenziert wurde, weiß der Linker nicht, worauf er Referenzen verweisen soll und beschwert sich über fehlende Symbole. Wenn Sie etwas mehr als einmal definieren, weiß der Linker nicht, auf welche der Definitionen verwiesen wird und beschwert sich über doppelte Symbole.

Seit der Diskussion, was eine Klassendeklaration gegenüber einer Klassendefinition in C ++ ist, immer wieder auftaucht (in Antworten und Kommentaren zu anderen Fragen), werde ich hier ein Zitat aus dem C ++ - Standard einfügen.
Bei 3.1 / 2 sagt C ++ 03:

Eine Deklaration ist eine Definition, es sei denn, es [...] ist eine Klassennamensdeklaration [...].

3.1 / 3 gibt dann ein paar 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: Der C ++ - Standard berücksichtigt struct x; eine Deklaration und struct x {}; eine Definition . (Mit anderen Worten, "Forward-Deklaration" ist eine Fehlbezeichnung , da es in C ++ keine anderen Formen von Klassendeklarationen gibt.)

Danke an Litb (Johannes Schaub), der in einer seiner Antworten das eigentliche Kapitel und den Vers ausgegraben hat.


Eine Deklaration führt einen Namen in das Programm ein; Eine Definition bietet eine eindeutige Beschreibung einer Entität (z. B. Typ, Instanz und Funktion). Deklarationen können in einem bestimmten Umfang wiederholt werden, es führt einen Namen in einem bestimmten Bereich ein. Es muss genau eine Definition jedes Objekts, jeder Funktion oder Klasse geben, die in einem C ++ - Programm verwendet wird. Eine Deklaration ist eine Definition, es sei denn:

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

Eine Definition ist eine Deklaration, es sei denn:

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

Es gibt interessante Randfälle in C ++ (einige davon auch in C). Erwägen

T t;

Dies kann eine Definition oder eine Deklaration sein, abhängig davon, welcher Typ 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 ++ gibt es bei der Verwendung von Vorlagen einen weiteren Randfall.

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 keine Definition. Es ist die Deklaration einer expliziten Spezialisierung des statischen Members von X<bool> . Es teilt dem Compiler mit: "Wenn es darum geht, X<bool>::member zu instanziieren, instanziieren Sie nicht die Definition des Members aus der primären Vorlage, sondern verwenden Sie die Definition woanders". Um es zu einer Definition zu machen, müssen Sie einen Initialisierer angeben

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

Faustregel:

  • Eine Deklaration teilt dem Compiler mit, wie die Daten der Variablen im Speicher zu interpretieren sind. Dies wird für jeden Zugriff benötigt.

  • Eine Definition reserviert den Speicher, um die Variable existent zu machen. Dies muss genau einmal vor dem ersten Zugriff geschehen.


Könnten Sie nicht allgemein sagen, dass eine Deklaration eine Kennung ist, in der kein Speicher zugeordnet ist und eine Definition tatsächlich Speicher von einer deklarierten Kennung zuweist?

Ein interessanter Gedanke: Eine Vorlage kann Speicher erst zuordnen, wenn die Klasse oder Funktion mit den Typinformationen verknüpft ist. Also ist die Vorlagenkennung eine Deklaration oder Definition? Es sollte eine Deklaration sein, da kein Speicher zugewiesen ist und Sie einfach die Template-Klasse oder -Funktion "prototypisieren".


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

In C stellt eine Deklaration lediglich Informationen bereit, dass eine Funktion oder Variable existiert und ihren Typ angibt. Für eine Funktionsdeklaration können Informationen über die Typen ihrer Argumente ebenfalls bereitgestellt werden. Der Zweck von Deklarationen besteht darin, dem Compiler zu ermöglichen, Verweise auf die deklarierten Variablen und Funktionen korrekt zu verarbeiten. Eine Definition hingegen weist Speicher für eine Variable zu oder sagt, was eine Funktion macht.


Um die Substantive zu verstehen, konzentrieren wir uns zuerst auf die Verben.

erklären - offiziell verkünden; proklamieren

Definieren - um (jemanden oder etwas) klar und vollständig zu zeigen oder zu beschreiben

Wenn Sie etwas erklären, sagen Sie einfach, was es ist .

// declaration
int sum(int, int);

Diese Zeile deklariert eine C-Funktion namens sum , die zwei Argumente vom Typ int übernimmt und einen int zurückgibt. Sie können es jedoch noch nicht verwenden.

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

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

Unterschied zwischen Deklaration und Definition mit Funktionen: Die Prototyp-Anweisung für eine Funktion deklariert sie, dh sie teilt dem Compiler die Funktion mit - Name, Rückgabetyp, Anzahl und Typ der Parameter. Der Funktionskopf, gefolgt vom Rumpf der Funktion, definiert die Funktion und gibt die Details der Schritte zum Ausführen der Funktionsoperation an.

Ex.

Code:

//Declare
int foo(int);

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

Mit Bezug auf Variablen: Bei automatischen und Registervariablen gibt es keinen Unterschied zwischen Definition und Deklaration. Der Prozess der Deklaration einer automatischen oder einer Registervariablen definiert den Variablennamen und ordnet entsprechenden Speicher zu.

Für externe Variablen: Weil Speicher für eine Variable nur einmal vergeben werden muss, um sicherzustellen, dass der Zugriff auf die Variable immer auf dieselbe Zelle verweist. Alle Variablen müssen einmalig definiert werden.

Wenn eine externe Variable in einer anderen Datei als der, in der sie definiert ist, verwendet werden soll, wird ein Mechanismus benötigt, um eine solche Verwendung mit der dafür definierten eindeutig definierten externen Variablenzelle zu verbinden. Dieser Vorgang des Verbindens der Referenzen derselben externen Variablen in verschiedenen Dateien wird als Auflösen der Referenzen bezeichnet.

Es kann mit einer Deklarationsanweisung außerhalb jeder Funktion definiert und deklariert werden, ohne Speicherklassenbezeichner. Eine solche Deklaration weist Speicher für die Variable zu. Eine Deklarationsanweisung kann auch verwendet werden, um einfach einen Variablennamen mit dem externen Speicherklassenspezifizierer am Anfang der Deklaration zu deklarieren. Eine solche Deklaration gibt an, dass die Variable an anderer Stelle definiert wird, dh Speicher für diese Variable wird in einer anderen Datei zugewiesen. Somit ist der Zugriff auf eine externe Variable in einer anderen Datei als der, in der sie definiert ist, möglich, wenn sie mit dem Schlüsselwort extern deklariert wird; Es wird kein neuer Speicher zugewiesen. Eine solche Deklaration teilt dem Compiler mit, dass die Variable an anderer Stelle definiert ist, und der Code wird kompiliert, wobei die externe Variable nicht aufgelöst wird. Der Verweis auf die externe Variable wird während des Verknüpfungsvorgangs aufgelöst.

Ex.

Code

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

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

Diese Deklarationen teilen dem Compiler mit, dass die Variablen stack [] und stkptr an anderer Stelle definiert sind, normalerweise in einer anderen Datei. Wenn das Schlüsselwort extern weggelassen würde, würden die Variablen als neue betrachtet und ihnen würde Speicher zugewiesen. Beachten Sie, dass der Zugriff auf dieselbe externe Variable, die in einer anderen Datei definiert ist, nur möglich ist, wenn das Schlüsselwort extern in der Deklaration verwendet wird.


Erklärung:

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

Die Deklaration assoziiert die Variable mit einem Typ.

Im Folgenden finden Sie einige Beispiele für die Deklaration.

int a;
float b;
double c;

Jetzt Funktionsdeklaration:

int fun(int a,int b); 

Beachten Sie das Semikolon am Ende der Funktion, damit es nur eine Deklaration ist. Der Compiler weiß, dass irgendwo im Programm diese Funktion mit diesem Prototyp definiert wird . Wenn nun der Compiler einen Funktionsaufruf bekommt, so etwas

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

Der Compiler wird einen Fehler ausgeben, der besagt, dass es keine solche Funktion gibt. Weil es für diese Funktion keinen Prototyp hat.

Beachten Sie den Unterschied zwischen zwei Programmen.

Programm 1

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

In diesem wird auch die Druckfunktion deklariert und definiert. Da Funktionsaufruf nach der Definition kommt. Jetzt 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);
 }

Dies ist wichtig, da der Funktionsaufruf der Definition vorausgeht, so dass der Compiler wissen muss, ob es eine solche Funktion gibt. Also deklarieren wir die Funktion, die den Compiler informieren wird.

Definition:

Dieser Teil der Definition einer Funktion heißt Definition. Er sagt, was in der Funktion zu tun ist.

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

Jetzt mit den Variablen.

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

Manchmal sind Deklaration und Definition in einer einzigen Anweisung wie dieser zusammengefasst.

int a=10;

Erklärung

Deklarationen sagen dem Compiler, dass ein Programmelement oder ein Name existiert. Eine Deklaration führt einen oder mehrere Namen in ein Programm ein. Deklarationen können mehrmals in einem Programm auftreten. Daher können Klassen, Strukturen, Aufzählungstypen und andere benutzerdefinierte Typen für jede Kompilierungseinheit deklariert werden.

Definition

Definitionen geben an, welchen Code oder Daten der Name beschreibt. Ein Name muss deklariert werden, bevor er verwendet werden kann.


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.


My favorite example is "int Num = 5" here your variable is 1. defined as int 2. declared as Num and 3. instantiated with a value of five. We

  • Define the type of an object, which may be built-in or a class or struct.
  • Declare the name of an object, so anything with a name has been declared which includes Variables, Funtions, etc.

A class or struct allows you to change how objects will be defined when it is later used. Beispielsweise

  • One may declare a heterogeneous variable or array which are not specifically defined.
  • Using an offset in C++ you may define an object which does not have a declared name.

When we learn programming these two terms are often confused because we often do both at the same time.


Whenever we write function after the main function, compiler will through the error since it does not have any idea about the function at the time of calling function. If we provide prototype declaration of function then we compiler will not look for the definition.

int sum(int,int);

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

In the above example , first line is called as function declaration.

int sum(int,int);

Declaring Variable

Whenever we write declaration statement then memory will not be allocated for the variable. Variable declaration will randomly specify the memory location.

int ivar;
float fvar;

Variable Declaration Vs Definition Differentiation Parameters

A. Space Reservation :

Whenever we declare a variable then space will not be reserved for the variable. Whenever we declare a variable then compiler will not look for other details such as definition of the variable.

Deklaration ist eine praktische Möglichkeit, Code zu schreiben, bei dem der tatsächliche Speicher nicht zugewiesen ist.

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

In der obigen Deklaration ist Speicher nicht belegt. Wann immer wir eine Variable definieren, wird Speicher für die Variable zugewiesen.

struct book b1;

B. Was macht es?

  1. Declaration identifiziert den Datentyp des Bezeichners.
  2. Die Definition der Variablen weist ihr einen gewissen Wert zu.




c++-faq