What is the difference between a definition and a declaration?

Frankly, I had a lot of trouble learning which was which, so I didn't find the names obvious. I had no problem with the meanings, just which names to associate with the meanings.

A much more interesting question is "difference between a declaration and a prototype": stackoverflow.com/questions/5481579/…

Here's a nice article that explains how the extern keyword and memory allocation relates to declarations / definitions: dreamincode.net/forums/topic/171468-declarations-vs-definitions

27 Answers 27

A declaration introduces an identifier and describes its type, be it a type, object, or function. A declaration is what the compiler needs to accept references to that identifier. These are declarations:

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 

A definition actually instantiates/implements this identifier. It's what the linker needs in order to link references to those entities. These are definitions corresponding to the above declarations:

int bar; int g(int lhs, int rhs) double f(int i, double d) class foo <>; 

A definition can be used in the place of a declaration.

An identifier can be declared as often as you want. Thus, the following is legal in C and 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); 

However, it must be defined exactly once. If you forget to define something that's been declared and referenced somewhere, then the linker doesn't know what to link references to and complains about a missing symbols. If you define something more than once, then the linker doesn't know which of the definitions to link references to and complains about duplicated symbols.

Since the debate what is a class declaration vs. a class definition in C++ keeps coming up (in answers and comments to other questions) , I'll paste a quote from the C++ standard here.
At 3.1/2, C++03 says:

A declaration is a definition unless it [. ] is a class name declaration [. ].

3.1/3 then gives a few examples. Amongst them:

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

To sum it up: The C++ standard considers struct x; to be a declaration and struct x <>; a definition. (In other words, "forward declaration" a misnomer, since there are no other forms of class declarations in C++.)

Thanks to litb (Johannes Schaub) who dug out the actual chapter and verse in one of his answers.

@unknown: either your compiler is broken of you have mis-copied sbi's code. For example, 6.7.2(2) in N1124: "All declarations that refer to the same object or function shall have compatible type; otherwise, the behavior is undefined."

@Brian: "extern int i;" says that i is an int somewhere, don't worry about it. "int i;" means that i is an int, and its address and scope is determined here.

@Brian: You're wrong. extern int i is a declaration, since it just introduces/specifies i . You can have as many extern int i in each compilation unit as you want. int i , however, is a definition. It denotes the space for the integer to be in this translation unit and advices the linker to link all references to i against this entity. If you have more or less than exactly one of these definitions, the linker will complain.

@Brian int i; in file/global scope or function scope is a definition both in C and C++. In C because it allocates storage, and in C++ because it does not have the extern specifier or a linkage-specification. These amount to the same thing, which is what sbi says: in both cases this declaration specifies the object to which all references to "i" in that scope must be linked.

@unknown, beware you cannot redeclare members in class scope: struct A < double f(int, double); double f(int, double); >; invalid, of course. It's allowed elsewhere though. There are some places where you can declare things, but not define, too: void f() < void g(); >valid, but not the following: void f() < void g() < >>; . What is a definition and what a declaration has subtle rules when it comes to templates - beware! +1 for a good answer though.

From the C++ standard section 3.1:

A declaration introduces names into a translation unit or redeclares names introduced by previous declarations. A declaration specifies the interpretation and attributes of these names.

The next paragraph states (emphasis mine) that a declaration is a definition unless.

. it declares a function without specifying the function’s body:

void sqrt(double); // declares sqrt 

. it declares a static member within a class definition:

struct X < int a; // defines a static int b; // declares b >; 

. it declares a class name:

class Y; 

. it contains the extern keyword without an initializer or function body:

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

. or is a typedef or using statement.

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

Now for the big reason why it's important to understand the difference between a declaration and definition: the One Definition Rule. From section 3.2.1 of the C++ standard:

No translation unit shall contain more than one definition of any variable, function, class type, enumeration type, or template.

"declares a static member within a class definition" - This is true even if the static member is initialised, correct? Can we make the example struct x ; ?

@RJFalconer You're correct; initialization does not necessarily turn a declaration into a definition (contrary to what one might expect; certainly I found this surprising). Your modification to the example is actually illegal unless b is also declared const . See stackoverflow.com/a/3536513/1858225 and daniweb.com/software-development/cpp/threads/140739/… .

This is interesting to me. According to your answer, it seems that in C++, a declaration is also a definition (with exceptions), whereas in the C standard it is phrased from the other perspective (C99, section 6.7, Declarations): "A definition of an identifier is a declaration for that identifier that: [followed by criteria for different cases]". Different ways to look at it, I suppose. :)

Declaration is for the compiler to accept a name(to tell the compiler that the name is legal, the name is introduced with intention not a typo). Definition is where a name and its content is associated. The definition is used by the linker to link a name reference to the content of the name.

Declaration: "Somewhere, there exists a foo."

Definition: ". and here it is!"

Declaration is for the compiler to accept a name(to tell the compiler that the name is legal, the name is introduced with intention not a typo). Definition is where a name and its content is associated. The definition is used by the linker to link a name reference to the content of the name.

There are interesting edge cases in C++ (some of them in C too). Consider

That can be a definition or a declaration, depending on what type T is:

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++, when using templates, there is another edge case.

template struct X < static int member; // declaration >; template int X::member; // definition template<> int X::member; // declaration! 

The last declaration was not a definition. It's the declaration of an explicit specialization of the static member of X . It tells the compiler: "If it comes to instantiating X::member , then don't instantiate the definition of the member from the primary template, but use the definition found elsewhere". To make it a definition, you have to supply an initializer

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

Declaration

Declarations tell the compiler that a program element or name exists. A declaration introduces one or more names into a program. Declarations can occur more than once in a program. Therefore, classes, structures, enumerated types, and other user-defined types can be declared for each compilation unit.

Definition

Definitions specify what code or data the name describes. A name must be declared before it can be used.

Um, isn't it that you can even define classes and enums in each compilation unit? At least I put class definitions into my headers and include them all over. Er, class foo <>; is a class definition, isn't it?

Yes. However, "class foo;" is a declaration. It tells the compiler that foo is a class. "class foo <>;" is a definition. It tells the compiler exactly what sort of class foo is.

Yeah, that's what i meant. So you can do the following: struct foo < void b() < f(); >void f(); >, f is visible even though not declared yet. The following works too: struct foo < void b(int = bar()); typedef int bar; >;. It's visible before its declaration in "all function bodies, default arguments, constructor ctor-initializers". Not in the return type :(

@litb: It isn't visible before it's declaration, it's only that the use of the identifier is moved behind the declaration. Yeah, I know, the effect is the same for many cases. But not for all cases, which is why I think we should use the precise explanation. -- Oops, wait. It is visible in default arguments? Well, that surely wreaks havoc with my understanding. Dammit!

From the C99 standard, 6.7(5):

A declaration specifies the interpretation and attributes of a set of identifiers. A definition of an identifier is a declaration for that identifier that:

• for an object, causes storage to be reserved for that object;
• for a function, includes the function body;
• for an enumeration constant or typedef name, is the (only) declaration of the identifier.

From the C++ standard, 3.1(2):

A declaration is a definition unless it declares a function without specifying the function's body, it contains the extern specifier or a linkage-specification and neither an initializer nor a function-body, it declares a static data member in a class declaration, it is a class name declaration, or it is a typedef declaration, a using-declaration, or a using-directive.

Then there are some examples.

So interestingly (or not, but I'm slightly surprised by it), typedef int myint; is a definition in C99, but only a declaration in C++.

@onebyone: Regarding the typedef , wouldn't that mean that it could be repeated in C++, but not in C99?

That's what surprised me, and as far as a single translation unit is concerned, yes there is that difference. But clearly a typedef can be repeated in C99 in different translation units. C doesn't have an explicit "one definition rule" like C++, so the rules it does have just allow it. C++ chose to change it to a declaration, but also the one definition rule lists what kinds of things it applies to, and typedefs isn't one of them. So repeats would be allowed in C++ under the ODR as it's worded, even if a typedef was a definition. Seems unnecessarily picky.

. but I'd guess that list in the ODR actually lists all the things it's possible to have definitions of. If so, then the list is actually redundant, and is just there to be helpful.

@sbi: ODR says "(1) No translation unit shall contain more than one definition of any . class type" and "(5) There can be more than one definition of a class type . in a program provided that each definition appears in a different translation unit" and then some extra requirements which amount to "the definitions are the same".

@SteveJessop: update your answer according to C11 standard because as you know C11 allows repeated typedef also.

The term declaration means (in C) that you are telling the compiler about type, size and in case of function declaration, type and size of its parameters of any variable, or user defined type or function in your program. No space is reserved in memory for any variable in case of declaration. However compiler knows how much space to reserve in case a variable of this type is created.

for example, following are all declarations:

extern int a; struct _tagExample < int a; int b; >; int myFunc (int a, int b); 

Definition on the other hand means that in additions to all the things that declaration does, space is also reserved in memory. You can say "DEFINITION = DECLARATION + SPACE RESERVATION" following are examples of definition:

int a; int b = 0; int myFunc (int a, int b) < return a + b; >struct _tagExample example; 

This, too, is wrong (although much closer than the others): struct foo <>; is a definition, not a declaration. A declaration of foo would be struct foo; . From that, the compiler doesn't know how much space to reserve for foo objects.

@Marcin: sbi is saying that "compiler knows how much space to reserve in case a variable of this type is created" is not always true. struct foo; is a declaration, but it does not tell the compiler the size of foo. I'd add that struct _tagExample < int a; int b; >; is a definition. So in this context it is misleading to call it a declaration. Of course it is one, since all definitions are declarations, but you seem to be suggesting that it is not a definition. It is a definition, of _tagExample.

@Marcin Gil: Which means that "Answers" wiki is not always accurate. I have to downvote for misinformation here.

We learn that what adatapost quoted is true but does not (IMO) really answer the question. What Marcin quoted is false. Quoting the standards is true and answers the question, but is very difficult to make head or tail of.

@onebyone: A very nice summary indeed! (I, however, had reinforced what I learned as a student and later tried to hammer into my students: Copying without thinking might lead to a disaster. :^> )

C++11 Update

Since I don't see an answer pertinent to C++11 here's one.

A declaration is a definition unless it declares a/n:

• opaque enum - enum X : int;
• template parameter - T in template class MyArray;
• parameter declaration - x and y in int add(int x, int y);
• alias declaration - using IntVector = std::vector;
• static assert declaration - static_assert(sizeof(int) == 4, "Yikes!")
• attribute declaration (implementation-defined)
• empty declaration ;

Additional clauses inherited from C++03 by the above list:

• function declaration - add in int add(int x, int y);
• extern specifier containing declaration or a linkage specifier - extern int a; or extern "C" < . >;
• static data member in a class - x in class C < static int x; >;
• class/struct declaration - struct Point;
• typedef declaration - typedef int Int;
• using declaration - using std::cout;
• using directive - using namespace NS;

A template-declaration is a declaration. A template-declaration is also a definition if its declaration defines a function, a class, or a static data member.

Examples from the standard which differentiates between declaration and definition that I found helpful in understanding the nuances between them:

// 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; // declares IntVector as an alias to std::vector 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 C; // declares template class C ; // declares nothing