定义和声明有什么区别？

声明意味着给变量命名和类型（在变量声明的情况下），例如：

int i;

或者给没有主体的函数命名、返回类型和参数类型（在函数声明的情况下），例如：

int max(int, int);

而定义意味着为变量赋值（在变量定义的情况下），例如：

i = 20;

或向函数提供/添加主体（功能）称为函数定义，例如：

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

许多时间声明和定义可以一起完成：

int i=20;

和：

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

在上述情况下，我们定义并声明变量i和function max()。

C++11更新

由于我没有看到与C++11相关的答案，这里有一个。

声明是定义，除非它声明了a/n：

• 不透明枚举-enum X : int;
• 模板参数-T intemplate<typename T> class MyArray;
• 参数声明-int add(int x, int y);中的x和y
• 别名声明-using IntVector = std::vector<int>;
• 静态断言声明-static_assert(sizeof(int) == 4, "Yikes!")
• 属性声明（实现定义）
• 空声明;

上述列表从C++03继承的附加条款：

• 函数声明-添加 inint add(int x, int y);
• 包含声明或链接说明符的extern说明符-extern int a;或extern "C" { ... };
• 类中的静态数据成员-x inclass C { static int x; };
• 类/结构声明-struct Point;
• typedef声明-typedef int Int;
• 使用声明-using std::cout;
• 使用指令-using namespace NS;

模板声明是一个声明。如果模板声明定义了函数、类或静态数据成员，则模板声明也是一个定义。

标准中区分声明和定义的示例，我发现这些示例有助于理解它们之间的细微差别：

// except one all these are definitionsint a;                                  // defines aextern const int c = 1;                 // defines cint f(int x) { return x + a; }          // defines f and defines xstruct S { int a; int b; };             // defines S, S::a, and S::bstruct X {                              // defines Xint x;                              // defines non-static data member xstatic int y;                       // DECLARES static data member yX(): x(0) { }                       // defines a constructor of X};int X::y = 1;                           // defines X::yenum { up , down };                     // defines up and downnamespace N { int d; }                  // defines N and N::dnamespace N1 = N;                       // defines N1X anX;                                  // defines anX

// all these are declarationsextern int a;                           // declares aextern const int c;                     // declares cint f(int);                             // declares fstruct S;                               // declares Stypedef int Int;                        // declares Intextern X anotherX;                      // declares anotherXusing N::d;                             // declares N::d

// specific to C++11 - these are not from the standardenum X : int;                           // declares X with int as the underlying typeusing 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 exprtemplate <class T> class C;             // declares template class C;                                       // declares nothing

这听起来真的很俗气，但这是我能够在脑海中保持这些条款的最佳方式：

声明：图片托马斯·杰斐逊发表演讲……“我在此宣布，这个FOO存在于这个源代码中！！！”

定义：想象一本字典，你正在查找Foo以及它的实际含义。

在这里找到类似的答案：C中的技术面试问题。

声明为程序提供了一个名称；定义提供了程序中实体（例如类型、实例和函数）的唯一描述。声明可以在给定范围内重复，它在给定范围内引入了一个名称。

声明是一个定义，除非：

• 声明声明了一个函数而没有指定它的主体，
• 声明包含一个extern说明符，没有初始化器或函数体，
• 声明是没有类定义的静态类数据成员的声明，
• 声明是一个类名定义，

定义是声明，除非：

• 定义定义了一个静态类数据成员，
• 定义定义一个非内联成员函数。

当你使用extern储存类别时，声明和定义的概念将成为一个陷阱，因为你的定义将在其他位置，并且你在本地代码文件（页面）中声明变量。C和C++的一个区别是，在C中，你的声明通常是在函数或代码页的开头完成的。C++不是这样的。你可以在你选择的地方声明。

我最喜欢的例子是“int Num=5”，这里您的变量是1.定义为int 2.声明为Num和3.实例化值为5。我们

• 定义对象的类型，可以是内置的，也可以是类或结构。
• 声明对象的名称，因此任何具有名称的东西都已声明，其中包括变量、函数等。

类或结构允许您更改以后使用对象时定义对象的方式。例如

• 可以声明一个未具体定义的异构变量或数组。
• 在C++中使用偏移量可以定义一个没有声明名称的对象。

当我们学习编程时，这两个术语经常被混淆，因为我们经常同时做这两件事。

定义：

extern int a;      // Declarationint a;             // Definitiona = 10             // Initializationint b = 10;        // Definition & Initialization

定义将变量与类型相关联并分配内存，而声明只是指定类型但不分配内存。当您想在定义之前引用变量时，声明更有用。

*不要混淆定义和初始化。两者是不同的，初始化为变量提供值。参见上面的例子。

以下是一些定义的例子。

int a;float b;double c;

现在函数声明：

int fun(int a,int b);

注意函数末尾的分号，所以它说这只是一个声明。编译器知道在程序的某个地方，该函数将使用该原型定义。现在，如果编译器得到这样的函数调用

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

编译器会抛出一个错误，说没有这样的函数。因为它没有该函数的任何原型。

注意两个程序之间的区别。

方案1

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

在这里，打印函数也被声明和定义。因为函数调用在定义之后。现在看下一个程序。

方案2

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

这很重要，因为函数调用先于定义，所以编译器必须知道是否有这样的函数。所以我们声明了会通知编译器的函数。

定义：

定义函数的这部分称为定义。它说明了在函数内部要做什么。

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

声明向编译器提供符号名称。定义是为符号分配空间的声明。

int f(int x); // function declaration (I know f exists)
int f(int x) { return 2*x; } // declaration and definition

要了解声明和定义之间的区别，我们需要查看汇编代码：

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        # 0x400a20movsd   %xmm0,-0x8(%rbp)

这只是定义：

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        # 0x400a20movsd   %xmm0,-0x8(%rbp)

你可以看到没有什么变化。

声明与定义不同，因为它提供的信息仅供编译器使用。例如uint8_t告诉编译器使用asm函数movb。

注意：

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

声明没有等价的指令，因为它不是要执行的东西。

此外，声明告诉编译器变量的范围。

我们可以说声明是编译器用来确定变量的正确使用以及某些内存属于某个变量的时间的信息。

为了理解名词，让我们先关注动词。

宣布-正式宣布；宣告

定义-清楚而完整地显示或描述（某人或某物）

所以，当你声明某事时，你只需告诉它是什么。

// declarationint sum(int, int);

这行宣布是一个名为sum的C函数，它接受两个int类型的参数并返回一个int。但是，您还不能使用它。

当你提供它是如何工作的时，这就是它的定义。

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

根据GNU C库手册（http://www.gnu.org/software/libc/manual/html_node/Header-Files.html）

在C语言中，声明仅仅提供了一个函数或变量存在的信息并给出了它的类型。对于函数声明，也可以提供关于其参数类型的信息。声明的目的是允许编译器正确处理对声明的变量和函数的引用。另一方面，定义实际上为变量分配存储空间或说明函数的作用。

可执行文件生成的阶段：

（1）预处理器->（2）翻译/编译器->（3）链接器

在第2阶段（翻译/编译器），我们代码中的声明语句告诉编译器我们将来会使用这些东西，您可以稍后找到定义，意思是：

翻译确保：什么是什么？表示声明

（3）阶段（链接器）需要定义来绑定事物

链接器确保：什么在哪里？表示定义

在K&R（第2版）中有一些非常明确的定义；将它们放在一个地方并将它们作为一个整体阅读是有帮助的：

“定义”是指变量被创建或分配存储的地方；“声明”是指变量的性质被声明但没有分配存储的地方。[p.33]

…

区分外部变量的声明和它的定义很重要。声明宣布变量的属性（主要是它的类型）；定义还会导致存储被预留。如果行

int sp;double val[MAXVAL]

出现在任何函数之外，它们定义外部变量sp和val，导致存储被留出，并作为该源文件其余部分的声明。

另一方面，线条

extern int sp;extern double val[];

宣布对于源文件的其余部分，sp是int，val是double数组（其大小在其他地方确定），但它们不会为它们创建变量或保留存储空间。

在构成源程序的所有文件中，必须只有一个外部变量的定义…数组大小必须用定义指定，但用extern声明是可选的。[pp.80-81]

…

声明指定对每个标识符的解释；它们不一定保留与标识符关联的存储。保留存储的声明称为定义。[p.210]

声明是在没有分配值或对象的情况下创建原始或对象引用变量或方法。int a；最后一个int a；

定义是指分别为值或对象赋值int a=10；

初始化意味着为相应的变量或对象分配内存。

变量的宣言用于通知编译器以下信息：变量的名称、它持有的值的类型和初始值（如果有的话）。即，声明给出了有关变量属性的详细信息。然而，变量的定义说明了变量的存储位置。也就是说，变量的内存是在变量的定义过程中分配的。

添加来自C++标准文档的定义和声明示例（来自第3.1节声明和定义）

定义：

int a;                       // defines aextern const int c = 1;      // defines cint f(int x) { return x+a; } // defines f and defines xstruct S { int a; int b; };  // defines S, S::a, and S::bstruct X {                   // defines Xint x;                   // defines non-static data member xstatic int y;            // DECLARES static data member yX(): x(0) { }            // defines a constructor of X};int X::y = 1;                // defines X::yenum { up, down };           // defines up and downnamespace N { int d; }       // defines N and N::dnamespace N1 = N;            // defines N1X anX;                       // defines anX

声明：

extern int a;                 // declares aextern const int c;           // declares cint f(int);                   // declares fstruct S;                     // declares Stypedef int Int;              // declares Intextern X anotherX;            // declares anotherXusing N::d;                   // declares d

宣言表示“这个东西存在于某处”

int sampleFunc(); // functionextern int car;  // variable

定义表示“这个东西存在于这里；为它创建内存”

int sampleFunc() {} // functionint car; // variable

初始化过程在对象的定义点是可选的，并表示“这是这个东西的初始值”：

int car = 0; // variable