Qual è la differenza tra una definizione e una dichiarazione?

Il significato di entrambi mi sfugge.

Una dichiarazione introduce un identificatore e ne descrive il tipo, sia esso un tipo, un oggetto o una funzione. Una dichiarazione è ciò di cui il compilatore deve accettare i riferimenti a quell'identificatore. Queste sono dichiarazioni:

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

Una definizione in realtà istanzia / implementa questo identificatore. È ciò di cui il linker ha bisogno per collegare riferimenti a tali entità. Queste sono definizioni corrispondenti alle dichiarazioni di cui sopra:

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

Una definizione può essere utilizzata al posto di una dichiarazione.

Un identificatore può essere dichiarato tutte le volte che vuoi. Pertanto, quanto segue è legale in C e 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);

Tuttavia, deve essere definito esattamente una volta. Se dimentichi di definire qualcosa che è stato dichiarato e referenziato da qualche parte, il linker non sa a cosa collegare i riferimenti e si lamenta di un simbolo mancante. Se definisci qualcosa più di una volta, il linker non sa a quale delle definizioni collegare i riferimenti e si lamenta dei simboli duplicati.

Dal momento che il dibattito su ciò che è una dichiarazione di classe contro una definizione di classe in C ++ continua (nelle risposte e nei commenti ad altre domande), incollerò qui una citazione dallo standard C ++.
A 3.1 / 2, C ++ 03 dice:

Una dichiarazione è una definizione a meno che [...] non sia una dichiarazione di nome di classe [...].

3.1 / 3 fornisce quindi alcuni esempi. Tra questi:

[Esempio: [...]
struct S {int a; int b; }; // definisce S, S :: a e S :: b [...]
struct S; // dichiara S
—Esempio

Per riassumere: lo standard C ++ considera struct x;una dichiarazione e struct x {};una definizione . (In altre parole, "dichiarazione in avanti" è un termine improprio , poiché non ci sono altre forme di dichiarazioni di classe in C ++.)

Grazie a litb (Johannes Schaub) che ha estratto il capitolo e il verso in una delle sue risposte.

Dallo standard C ++ sezione 3.1:

Una dichiarazione introduce i nomi in un'unità di traduzione o redige le dichiarazioni introdotte da dichiarazioni precedenti. Una dichiarazione specifica l'interpretazione e gli attributi di questi nomi.

Il prossimo paragrafo afferma (enfatizzare il mio) che una dichiarazione è una definizione a meno che ...

... dichiara una funzione senza specificare il corpo della funzione:

void sqrt(double);  // declares sqrt

... dichiara un membro statico all'interno di una definizione di classe:

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

... dichiara un nome di classe:

class Y;

... contiene la externparola chiave senza inizializzatore o corpo della funzione:

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

... o è una dichiarazione typedefo using.

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

Ora, per la grande ragione per cui è importante capire la differenza tra una dichiarazione e una definizione: la regola della definizione unica . Dalla sezione 3.2.1 della norma C ++:

Nessuna unità di traduzione deve contenere più di una definizione di variabile, funzione, tipo di classe, tipo di enumerazione o modello.

Dichiarazione: "Da qualche parte esiste un foo".

Definizione: "... ed eccolo qui!"

Ci sono casi limite interessanti in C ++ (alcuni anche in C). Prendere in considerazione

T t;

Può essere una definizione o una dichiarazione, a seconda del tipo 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".

In C ++, quando si usano i template, c'è un altro caso limite.

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

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

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

L'ultima dichiarazione non era una definizione. È la dichiarazione di una specializzazione esplicita del membro statico di X<bool>. Indica al compilatore: "Se si tratta di X<bool>::membercreare un'istanza , quindi non creare un'istanza della definizione del membro dal modello principale, ma utilizzare la definizione trovata altrove". Per renderlo una definizione, è necessario fornire un inizializzatore

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

Dichiarazione

Le dichiarazioni indicano al compilatore che esiste un elemento o un nome di programma. Una dichiarazione introduce uno o più nomi in un programma. Le dichiarazioni possono verificarsi più di una volta in un programma. Pertanto, classi, strutture, tipi enumerati e altri tipi definiti dall'utente possono essere dichiarati per ogni unità di compilazione.

Definizione

Le definizioni specificano quale codice o dati descrive il nome. Un nome deve essere dichiarato prima di poter essere utilizzato.

Dallo standard C99, 6.7 (5):

Una dichiarazione specifica l'interpretazione e gli attributi di un insieme di identificatori. Una definizione di un identificatore è una dichiarazione per quell'identificatore che:

• per un oggetto, fa sì che la memoria sia riservata per quell'oggetto;
• per una funzione, include il corpo della funzione;
• per una costante di enumerazione o il nome typedef, è la (unica) dichiarazione dell'identificatore.

Dallo standard C ++, 3.1 (2):

Una dichiarazione è una definizione a meno che non dichiari una funzione senza specificare il corpo della funzione, contiene l'identificatore esterno o una specifica di collegamento e né un inizializzatore né un corpo di funzione, dichiara un membro di dati statici in una dichiarazione di classe, è un dichiarazione del nome della classe o è una dichiarazione typedef, una dichiarazione using o una direttiva using.

Quindi ci sono alcuni esempi.

È così interessante (o no, ma ne sono leggermente sorpreso), typedef int myint;è una definizione in C99, ma solo una dichiarazione in C ++.

Da wiki.answers.com:

Il termine dichiarazione significa (in C) che stai dicendo al compilatore di tipo, dimensione e in caso di dichiarazione di funzione, tipo e dimensione dei suoi parametri di qualsiasi variabile, o tipo o funzione definiti dall'utente nel tuo programma. Nessuno spazio è riservato in memoria per qualsiasi variabile in caso di dichiarazione. Tuttavia il compilatore sa quanto spazio riservare nel caso in cui venga creata una variabile di questo tipo.

ad esempio, di seguito sono riportate tutte le dichiarazioni:

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

La definizione d'altra parte significa che oltre a tutto ciò che fa la dichiarazione, lo spazio è anche riservato nella memoria. Puoi dire "DEFINIZIONE = DICHIARAZIONE + PRENOTAZIONE SPAZIO" di seguito sono riportati esempi di definizione:

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

vedi Risposte .

Aggiornamento C ++ 11

Dal momento che non vedo una risposta pertinente a C ++ 11 eccone una.

Una dichiarazione è una definizione a meno che non dichiari a / n:

• enum opaco - enum X : int;
• parametro template - T intemplate<typename T> class MyArray;
• dichiarazione di parametro - x ed y inint add(int x, int y);
• dichiarazione alias - using IntVector = std::vector<int>;
• dichiarazione di asserzione statica - static_assert(sizeof(int) == 4, "Yikes!")
• dichiarazione di attributo (definita dall'implementazione)
• dichiarazione vuota ;

Clausole aggiuntive ereditate da C ++ 03 dall'elenco precedente:

• dichiarazione di funzione - aggiungere aint add(int x, int y);
• specificatore esterno contenente una dichiarazione o un identificatore di collegamento - extern int a;oppureextern "C" { ... };
• membro di dati statici in una classe - x inclass C { static int x; };
• dichiarazione di classe / struttura - struct Point;
• dichiarazione typedef - typedef int Int;
• usando la dichiarazione - using std::cout;
• usando la direttiva - using namespace NS;

Una dichiarazione modello è una dichiarazione. Una dichiarazione modello è anche una definizione se la sua dichiarazione definisce una funzione, una classe o un membro di dati statici.

Esempi dallo standard che distingue tra dichiarazione e definizione che ho trovato utile per comprendere le sfumature tra di loro:

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

Definizione:

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

La definizione associa la variabile a un tipo e alloca la memoria, mentre la dichiarazione specifica solo il tipo ma non alloca la memoria. La dichiarazione è più utile quando si desidera fare riferimento alla variabile prima della definizione.

* Non confondere la definizione con l'inizializzazione. Entrambi sono diversi, l'inizializzazione dà valore alla variabile. Vedi l'esempio sopra.

Di seguito sono riportati alcuni esempi di definizione.

int a;
float b;
double c;

Ora dichiarazione di funzione:

int fun(int a,int b); 

Nota il punto e virgola alla fine della funzione, quindi dice che è solo una dichiarazione. Il compilatore sa che da qualche parte nel programma tale funzione verrà definita con quel prototipo. Ora se il compilatore riceve una funzione chiama qualcosa del genere

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

Il compilatore genererà un errore dicendo che non esiste tale funzione. Perché non ha alcun prototipo per quella funzione.

Nota la differenza tra due programmi.

Programma 1

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

In questo, viene dichiarata e definita anche la funzione di stampa. Poiché la chiamata di funzione sta arrivando dopo la definizione. Ora guarda il prossimo programma.

Programma 2

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

È essenziale perché la chiamata di funzione precede la definizione, quindi il compilatore deve sapere se esiste una tale funzione. Quindi dichiariamo la funzione che informerà il compilatore.

Definizione:

Questa parte della definizione di una funzione è chiamata Definizione. Dice cosa fare all'interno della funzione.

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

definizione significa funzione effettiva scritta e dichiarazione significa funzione di dichiarazione semplice per es

void  myfunction(); //this is simple declaration

e

void myfunction()
{
 some statement;    
}

questa è la definizione della funzione myfunction

Regola del pollice:

• Una dichiarazione indica al compilatore come interpretare i dati della variabile in memoria. Questo è necessario per ogni accesso.

• Una definizione riserva la memoria per rendere esistente la variabile. Questo deve avvenire esattamente una volta prima del primo accesso.

Per capire i nomi, concentriamoci prima sui verbi.

dichiarare - annunciare ufficialmente; proclamare

definire - per mostrare o descrivere (qualcuno o qualcosa) in modo chiaro e completo

Quindi, quando dichiari qualcosa, dici semplicemente di cosa si tratta .

// declaration
int sum(int, int);

Questa riga dichiara una funzione C chiamata sumche accetta due argomenti di tipo inte restituisce un int. Tuttavia, non puoi ancora usarlo.

Quando fornisci come funziona effettivamente , questa è la sua definizione.

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

Per comprendere la differenza tra dichiarazione e definizione, è necessario vedere il codice assembly:

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)

e questa è solo la definizione:

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)

Come vedi nulla cambia.

La dichiarazione è diversa dalla definizione perché fornisce informazioni utilizzate solo dal compilatore. Ad esempio uint8_t dice al compilatore di usare la funzione asb movb.

Guarda quello:

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

La dichiarazione non ha un'istruzione equivalente perché non è qualcosa da eseguire.

Inoltre la dichiarazione indica al compilatore l'ambito della variabile.

Possiamo dire che la dichiarazione è un'informazione utilizzata dal compilatore per stabilire l'uso corretto della variabile e per quanto tempo parte della memoria appartiene a una determinata variabile.

Non potresti affermare nei termini più generali possibili che una dichiarazione è un identificatore in cui non è allocata alcuna memoria e una definizione alloca effettivamente la memoria da un identificatore dichiarato?

Un pensiero interessante: un modello non può allocare l'archiviazione fino a quando la classe o la funzione non sono collegate alle informazioni sul tipo. Quindi l'identificatore del modello è una dichiarazione o una definizione? Dovrebbe essere una dichiarazione poiché non è stata allocata alcuna memoria e si sta semplicemente "prototipando" la classe o la funzione del modello.

Trova le risposte simili qui: intervista domande tecniche in C .

Una dichiarazione fornisce un nome al programma; una definizione fornisce una descrizione univoca di un'entità (ad esempio tipo, istanza e funzione) all'interno del programma. Le dichiarazioni possono essere ripetute in un determinato ambito, introducono un nome in un determinato ambito.

Una dichiarazione è una definizione a meno che:

• La dichiarazione dichiara una funzione senza specificarne il corpo,
• La dichiarazione contiene un identificatore esterno e nessun inizializzatore o corpo della funzione,
• Dichiarazione è la dichiarazione di un membro di dati di classe statica senza una definizione di classe,
• La dichiarazione è una definizione di nome di classe,

Una definizione è una dichiarazione a meno che:

• La definizione definisce un membro di dati di classe statica,
• La definizione definisce una funzione membro non incorporata.

Questo suonerà davvero di cattivo gusto, ma è il modo migliore in cui sono stato in grado di mantenere i termini nella mia testa:

Dichiarazione: Picture Thomas Jefferson mentre tiene un discorso ... "DICHIARO QUESTO QUESTO FOO ESISTE IN QUESTO CODICE SORGENTE !!!"

Definizione: immagina un dizionario, stai cercando Foo e cosa significa in realtà.

Una dichiarazione presenta un nome simbolo al compilatore. Una definizione è una dichiarazione che alloca spazio per il simbolo.

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

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

Secondo il manuale della libreria GNU C ( http://www.gnu.org/software/libc/manual/html_node/Header-Files.html )

In C, una dichiarazione fornisce semplicemente informazioni sull'esistenza di una funzione o variabile e ne fornisce il tipo. Per una dichiarazione di funzione, potrebbero essere fornite anche informazioni sui tipi dei suoi argomenti. Lo scopo delle dichiarazioni è di consentire al compilatore di elaborare correttamente i riferimenti alle variabili e funzioni dichiarate. Una definizione, d'altra parte, alloca l'archiviazione per una variabile o dice cosa fa una funzione.

Il concetto di Dichiarazione e Definizione costituirà una trappola quando si utilizza la classe di archiviazione esterna perché la definizione si troverà in un'altra posizione e si sta dichiarando la variabile nel file di codice locale (pagina). Una differenza tra C e C ++ è che in C le dichiarazioni sono fatte normalmente all'inizio di una funzione o di una tabella codici. In C ++ non è così. Puoi dichiarare in un luogo di tua scelta.

Il mio esempio preferito è "int Num = 5" qui la tua variabile è 1. definita come int 2. dichiarata come Num e 3. istanziata con un valore di cinque. Noi

• Definire il tipo di un oggetto, che può essere incorporato o una classe o struttura.
• Dichiara il nome di un oggetto, quindi è stato dichiarato qualsiasi cosa con un nome che includa Variabili, Funzioni, ecc.

Una classe o struttura ti consente di cambiare il modo in cui gli oggetti verranno definiti quando verrà utilizzato in seguito. Per esempio

• Si può dichiarare una variabile o matrice eterogenea che non sono specificamente definite.
• Usando un offset in C ++ puoi definire un oggetto che non ha un nome dichiarato.

Quando impariamo a programmare questi due termini sono spesso confusi perché spesso facciamo entrambi allo stesso tempo.

Fasi di una generazione eseguibile:

(1) pre-processore -> (2) traduttore / compilatore -> (3) linker

Nella fase 2 (traduttore / compilatore), le dichiarazioni di dichiarazione nel nostro codice dicono al compilatore che queste cose useremo in futuro e puoi trovare la definizione in seguito, il significato è:

traduttore assicurarsi che: che cosa è che cosa? significa dichiarazione

e (3) fase (linker) ha bisogno di definizione per legare le cose

Linker si assicura che: dov'è cosa? significa definizione

Ci sono alcune definizioni molto chiare sparse in tutta K&R (2a edizione); aiuta a metterli in un posto e a leggerli come uno:

"Definizione" si riferisce al luogo in cui viene creata o assegnata la memoria; "dichiarazione" si riferisce ai luoghi in cui è indicata la natura della variabile ma non è stata allocata alcuna memoria. [P. 33]

...

È importante distinguere tra la dichiarazione di una variabile esterna e la sua definizione . Una dichiarazione annuncia le proprietà di una variabile (principalmente il suo tipo); una definizione causa anche l'archiviazione dell'archiviazione. Se le linee

int sp;
double val[MAXVAL]

appaiono al di fuori di qualsiasi funzione, definiscono le variabili esterne spe val, causano l'archiviazione dell'archiviazione e fungono anche da dichiarazione per il resto del file sorgente.

D'altra parte, le linee

extern int sp;
extern double val[];

dichiarare per il resto del file sorgente che spè unint e che valè un doublearray (la cui dimensione è determinata altrove), ma non creano le variabili né riservano spazio per essi.

Deve essercene solo uno definizione di una variabile esterna tra tutti i file che compongono il programma di origine. ... Le dimensioni dell'array devono essere specificate con la definizione, ma sono facoltative con una externdichiarazione. [pp. 80-81]

...

Le dichiarazioni specificano l'interpretazione data a ciascun identificatore; non riservano necessariamente la memoria associata all'identificatore. Le dichiarazioni che riservano l'archiviazione sono chiamate definizioni . [p. 210]

Dichiarazione significa dare nome e tipo a una variabile (in caso di dichiarazione variabile), ad esempio:

int i;

oppure assegnare nome, tipo di ritorno e tipo di parametro a una funzione senza corpo (in caso di dichiarazione di funzione), ad esempio:

int max(int, int);

mentre definizione significa assegnare valore a una variabile (in caso di definizione variabile), ad esempio:

i = 20;

o fornire / aggiungere corpo (funzionalità) a una funzione è chiamata definizione di funzione, ad es .:

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

molte dichiarazioni e definizioni temporali possono essere fatte insieme come:

int i=20;

e:

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

Nei casi precedenti definiamo e dichiariamo variabili ie function max().