Jaka jest różnica między definicją a deklaracją?

Ze standardu C++ sekcja 3.1:

A deklaracja wprowadza nazwy do jednostki tłumaczeniowej lub zmienia nazwy wprowadzone przez poprzednie deklaracje. Deklaracja określa interpretację i atrybuty tych nazw.

Następny akapit stwierdza (podkreślenie), że deklaracja jest definicją chyba...

... deklaruje funkcję bez podania ciała funkcji:

void sqrt(double);  // declares sqrt

... deklaruje on statyczny element w definicji klasy:

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

... deklaruje nazwę klasy:

class Y;

... zawiera słowo kluczowe extern bez inicjalizacji lub ciała funkcji:

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

... lub jest typedef lub using stwierdzeniem.

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

Teraz z ważnego powodu, dla którego ważne jest zrozumienie różnicy między deklaracją a definicją: jedna zasada definicji. Z sekcji 3.2.1 standardu C++:

Żadna jednostka tłumaczeniowa nie może zawierać więcej niż jedna definicja dowolnej zmiennej, funkcji, typu klasy, typu wyliczenia lub szablonu.

Deklaracja: "gdzieś istnieje foo."

Definicja: "...i oto jest!"

W C++ są interesujące przypadki krawędzi(niektóre z nich również w C). Consider

T t;

Może to być definicja lub deklaracja, w zależności od tego, jakiego typu T jest:

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

W C++, podczas korzystania z szablonów, istnieje inny przypadek edge.

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

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

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

Ostatnia deklaracja była , a nie definicją. Jest to deklaracja wyraźnej specjalizacji statycznego członka X<bool>. Mówi kompilatorowi: "jeśli chodzi o tworzenie instancji X<bool>::member, to nie definicja członu z szablonu podstawowego, ale użyj definicji znalezionej gdzie indziej". Aby uczynić z niej definicję, musisz podać inicjalizator

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

Deklaracja

Deklaracje mówią kompilatorowi, że a element programu lub nazwa istnieje. A deklaracja wprowadza jedną lub więcej nazwy do programu. Deklaracje mogą występują więcej niż raz w programie. Dlatego klasy, struktury, wymienione typy i inne typy zdefiniowane przez użytkownika mogą być deklarowane dla każda jednostka kompilacji.

Definicja

Definicje określają kod lub dane nazwa opisuje. Imię musi be deklarowane przed jego użyciem.

Ze standardu C99, 6.7 (5):

Deklaracja określa interpretację i atrybuty zbioru identyfikatorów. A definicja identyfikatora jest deklaracją dla tego identyfikatora, że:

• dla obiektu, powoduje, że przechowywanie jest zarezerwowane dla tego obiektu;
• dla funkcji, zawiera Ciało funkcji;
• dla stałej wyliczeniowej lub nazwy typu, jest (jedyną) deklaracją identyfikator.

Ze standardu C++ , 3.1(2):

Deklaracja jest definicją o ile nie deklaruje funkcji bez podania jej ciała, zawiera specyfikator extern lub specyfikację linkage i ani inicjalizator, ani Ciało funkcji, deklaruje statyczny element danych w deklaracji klasy, jest deklaracją nazwy klasy lub jest deklaracją typedef, deklaracją using-declaration lub dyrektywą using-directive.

Jest kilka przykładów.

Ciekawe (albo nie, ale jestem nieco typedef int myint; jest definicją w C99, ale tylko deklaracją w C++.

Od wiki.answers.com:

Termin deklaracja oznacza (w C), że informujesz kompilator o typie, rozmiarze, a w przypadku deklaracji funkcji, typie i rozmiarze jej parametrów dowolnej zmiennej lub zdefiniowanego przez użytkownika typu lub funkcji w twoim programie. Brak spacji jest zarezerwowany w pamięci dla dowolnej zmiennej w przypadku deklaracji. Kompilator wie jednak, ile miejsca należy zarezerwować w przypadku utworzenia zmiennej tego typu.

Na przykład, poniżej znajdują się wszystkie deklaracje:

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

Definicja z drugiej strony oznacza, że w uzupełnieniach do wszystkich rzeczy, które robi deklaracja, przestrzeń jest również zarezerwowana w pamięci. Można powiedzieć "definicja = deklaracja + zastrzeżenie przestrzeni" poniżej znajdują się przykłady definicji:

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

Zobacz Odpowiedzi.

C++11 Update

Ponieważ nie widzę odpowiedzi dotyczącej C++11 tutaj jest jedna.

Deklaracja jest definicją , chyba że deklaruje a / n:

• nieprzezroczyste enum- enum X : int;
• parametr szablonu - T w template<typename T> class MyArray;
• deklaracja parametrów- x i y W int add(int x, int y);
• deklaracja aliasu- using IntVector = std::vector<int>;
• static assert declaration - static_assert(sizeof(int) == 4, "Yikes!")
• deklaracja atrybutów (implementation-defined)
• pusta deklaracja ;

Dodatkowe klauzule dziedziczone z C++03 przez powyższą listę:

• deklaracja funkcji- dodaj W int add(int x, int y);
• extern specifier zawierający deklarację lub specyfikator linkowania - extern int a; lub extern "C" { ... };
• static data member in a class - x in class C { static int x; };
• deklaracja klasy/struktury- struct Point;
• deklaracja typedef- typedef int Int;
• używanie deklaracji - using std::cout;
• using directive- using namespace NS;

Wzór-deklaracja jest deklaracją. Szablon-deklaracja jest również definicją, jeśli jego deklaracja definiuje funkcję, klasę lub statyczny element danych.

Przykłady ze standardu, który rozróżnia deklaracje i definicje, które uznałem za pomocne w zrozumieniu niuansów między nimi:

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

Definicja:

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

Definicja kojarzy zmienną z typem i przydziela pamięć, podczas gdy deklaracja tylko określa typ, ale nie przydziela pamięci. Deklaracja jest bardziej przydatna, gdy chcemy odwołać się do zmiennej przed zdefiniowaniem.

*nie myl definicji z inicjalizacją. Oba są różne, inicjalizacja daje wartość zmiennej. Zobacz powyższy przykład.

Oto kilka przykładów definicja.

int a;
float b;
double c;

Teraz deklaracja funkcji:

int fun(int a,int b); 

Zwróć uwagę na średnik na końcu funkcji, więc mówi, że jest to tylko deklaracja. Kompilator wie, że gdzieś w Programie Ta funkcja będzie zdefiniowana z tym prototypem. Teraz, jeśli kompilator otrzyma funkcję wywołującą coś takiego

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

Kompilator wyrzuci błąd mówiący, że nie ma takiej funkcji. Ponieważ nie ma żadnego prototypu dla tej funkcji.

Zwróć uwagę na różnica między dwoma programami.

Program 1

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

Funkcja print jest również zadeklarowana i zdefiniowana. Ponieważ wywołanie funkcji następuje po definicji. Teraz Zobacz następny program.

Program 2

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

Jest to istotne, ponieważ wywołanie funkcji poprzedza definicję, więc kompilator musi wiedzieć, czy istnieje taka funkcja. Deklarujemy więc funkcję, która poinformuje kompilator.

Definicja:

Ta część definiowania funkcji nazywa się definicją. Mówi, co robić wewnątrz funkcji.

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

Aby zrozumieć rzeczowniki, skupmy się najpierw na czasownikach.

Declare - ogłosić oficjalnie; proklamować

Define - aby pokazać lub opisać (kogoś lub coś) wyraźnie i całkowicie

Więc kiedy coś deklarujesz, po prostu mówisz co to jest.

// declaration
int sum(int, int);

Ta linia deklaruje funkcję C o nazwie sum, która pobiera dwa argumenty typu int i zwraca int. Jednak nie możesz go jeszcze użyć.

Kiedy podaj Jak to faktycznie działa , taka jest jego definicja.

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

Definition mean actual function written & declaration mean simple declare function dla np.

void  myfunction(); //this is simple declaration

I

void myfunction()
{
 some statement;    
}

Jest to definicja funkcji mojafunkcja

Zasada kciuka:

• Deklaracja mówi kompilatorowi, jak interpretować dane zmiennej w pamięci. Jest to potrzebne przy każdym dostępie.

• Definicja zastrzega pamięć, aby zmienna istniała. Musi to nastąpić dokładnie raz przed pierwszym dostępem.

Aby zrozumieć różnicę między deklaracją a definicją musimy zobaczyć kod 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)

I to jest tylko definicja:

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)

Deklaracja różni się od definicji, ponieważ podaje informacje używane tylko przez kompilator. Na przykład uint8_t mówi kompilatorowi, aby używał funkcji ASM movb.

Zobacz też:

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

Deklaracja nie ma równoważnej instrukcji, ponieważ nie jest czymś, co powinno być stracony.

Ponadto deklaracja mówi kompilatorowi zakres zmiennej.

Możemy powiedzieć, że deklaracja jest informacją używaną przez kompilator do ustalenia poprawnego użycia zmiennej i jak długo dana pamięć należy do danej zmiennej.

Czy nie mógłbyś podać w możliwie najbardziej ogólnym ujęciu, że deklaracja jest identyfikatorem, w którym nie jest alokowany magazyn, a definicja faktycznie przydziela magazyn od zadeklarowanego identyfikatora?

Jedna ciekawa myśl - szablon nie może przydzielić pamięci masowej, dopóki klasa lub funkcja nie zostaną połączone z informacją o typie. Czy identyfikator szablonu jest deklaracją lub definicją? Powinna to być deklaracja, ponieważ nie ma miejsca na przechowywanie, a ty po prostu "prototypujesz" klasa szablonu lub funkcja.

Znajdź podobne odpowiedzi tutaj: pytania wywiadu Technicznego w C .

A deklaracja zawiera nazwę programu; a definicja zawiera unikalny opis encji (np. typu, instancji i funkcji) w programie. Deklaracje mogą być powtarzane w danym zakresie, wprowadza nazwę w danym zakresie.

Deklaracja jest definicją, chyba że:

• Deklaracja deklaruje funkcję bez podania jej body,
• deklaracja zawiera extern specifier i nie ma inicjalizatora ani ciała funkcji,
• deklaracja jest deklaracją statycznego elementu danych klasy bez definicji klasy,
• deklaracja jest definicją nazwy klasy,

Definicja jest deklaracją, chyba że:

• definicja definiuje statyczny element danych klasy,
• definicja definiuje funkcję nie-inline member.

To zabrzmi naprawdę tandetnie, ale to najlepszy sposób, w jaki udało mi się utrzymać terminy prosto w głowie:

Deklaracja: Obraz Thomasa Jeffersona wygłaszającego przemówienie... "NINIEJSZYM OŚWIADCZAM, ŻE FOO ISTNIEJE W TYM KODZIE ŹRÓDŁOWYM!!!"

Definicja: wyobraź sobie słownik, szukasz Foo i co to właściwie znaczy.

Deklaracja przedstawia kompilatorowi nazwę symbolu. Definicja jest deklaracją, która przydziela przestrzeń dla symbolu.

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

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

Zgodnie z podręcznikiem biblioteki GNU C ( http://www.gnu.org/software/libc/manual/html_node/Header-Files.html )

W C, deklaracja dostarcza jedynie informacji o istnieniu funkcji lub zmiennej i podaje jej typ. W przypadku deklaracji funkcji można również podać informacje o typach jej argumentów. Celem deklaracji jest umożliwienie kompilatorowi poprawnego przetwarzania odwołań do zadeklarowanych zmiennych i funkcji. Definicja, na z drugiej strony, faktycznie przydziela miejsce na zmienną lub mówi, co robi funkcja.

Pojęcie deklaracji i definicji będzie stanowić pułapkę, gdy używasz klasy extern storage, ponieważ twoja definicja będzie w innej lokalizacji i deklarujesz zmienną w lokalnym pliku kodu (strona). Jedną z różnic między C i C++ jest to, że w C you deklaracje są wykonywane normalnie na początku funkcji lub strony kodowej. W C++ to nie tak. Możesz zadeklarować w wybranym przez siebie miejscu.

Moim ulubionym przykładem jest "int Num = 5" tutaj twoja zmienna to 1. zdefiniowany jako int 2. zadeklarowana jako Num i 3. instancja z wartością 5. My

• Zdefiniuj typ obiektu, który może być wbudowany lub klasy lub struktury.
• deklaruje nazwę obiektu, więc zadeklarowano wszystko, co ma nazwę, która zawiera zmienne, Funcje itp.

Klasa lub struktura pozwala zmienić sposób definiowania obiektów, gdy są później używane. Na przykład

• Można zadeklarować zmienną heterogeniczną lub tablicę, które nie są ściśle zdefiniowane.
• używając offsetu w C++ można zdefiniować obiekt, który nie ma zadeklarowanej nazwy.

Kiedy uczymy się programowania te dwa terminy są często mylone, ponieważ często robimy oba w tym samym czasie.

Etapy generowania pliku wykonywalnego:

(1) pre-processor -> (2) translator/kompilator -> (3) linker

W etapie 2 (translator/kompilator), deklaracje w naszym kodzie mówią kompilatorowi, że te rzeczy będziemy używać w przyszłości, a definicję znajdziesz później, czyli:

Tłumacz upewnij się, że: co jest czym ? oznacza deklarację

And (3) stage (linker) needs definition to bind the things

Linker upewnij się, że: gdzie jest co ? oznacza definicję

Istnieje kilka bardzo jasnych definicji rozsypanych W K & R( 2nd edition); pomaga umieścić je w jednym miejscu i odczytać je jako jedno:

"definicja" odnosi się do miejsca, w którym zmienna jest tworzona lub przypisana do magazynu; "deklaracja" odnosi się do miejsc, w których podano charakter zmiennej, ale nie przydzielono magazynu. [str. 33]

...

Ważne jest rozróżnienie deklaracji zmiennej zewnętrznej i jej definicja . Deklaracja informuje o właściwościach zmiennej (przede wszystkim jej rodzaju); definicja powoduje również wyłączenie przechowywania. If the lines

int sp;
double val[MAXVAL]

Pojawiają się poza dowolną funkcją, definiują zewnętrzne zmienne sp i val, powodują wyłączenie przechowywania i służą jako deklaracja dla reszty tego pliku źródłowego.

Z drugiej strony linie

extern int sp;
extern double val[];

declare for the rest of the source plik, który sp jest tablicą int I val jest tablicą double (której rozmiar jest określony w innym miejscu), ale nie tworzą zmiennych ani nie przechowują dla nich rezerwy.

Musi być tylko jedna definicja zewnętrznej zmiennej wśród wszystkich plików składających się na program źródłowy. ... Rozmiary tablic muszą być określone za pomocą definicji, ale są opcjonalne za pomocą deklaracji extern. [s. 80-81]

...

Deklaracje określają interpretację udzieloną każdy identyfikator; nie muszą one rezerwować przechowywania związanego z identyfikatorem. Deklaracje, że skład rezerwowy nazywa się definicjami . [str. 210]

Deklaracja jest wtedy, gdy zmienna lub metoda odniesienia primitive lub object jest tworzona bez przypisywania wartości lub obiektu. int a; final int a;

Definicja oznacza przypisanie odpowiednio wartości lub obiektu int a = 10;

Inicjalizacja oznacza alokację pamięci dla danej zmiennej lub obiektu.

Deklaracja oznacza nadanie nazwy i typu zmiennej (w przypadku deklaracji zmiennej), np.:

int i;

Lub podać nazwę, typ zwracany i typ parametru funkcji bez ciała(w przypadku deklaracji funkcji), np:

int max(int, int);

Definicja oznacza przypisanie wartości zmiennej (w przypadku definicji zmiennej), np.:

i = 20;

Lub podanie/dodanie ciała (funkcjonalności) do funkcji nazywa się definicją funkcji, np.:

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

Wiele deklaracji i definicji czasu można wykonać razem jako:

int i=20;

I:

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

W powyższych przypadkach definiujemy i deklarujemy zmienne i i function max().