我不明白两者的意义。
从wiki.answers.com:
术语声明(在C语言中)意味着你告诉编译器关于类型，大小，如果是函数声明，任何变量的参数的类型和大小，或者程序中用户定义的类型或函数。在声明时，内存中不为任何变量保留空间。然而，编译器知道在这种类型的变量被创建的情况下要保留多少空间。
例如，以下是所有的声明:
extern int a;
struct _tagExample { int a; int b; };
int myFunc (int a, int b);
另一方面，定义意味着除了声明所做的所有事情之外，内存中还保留了空间。你可以说“DEFINITION = DECLARATION + SPACE RESERVATION”，下面是定义的例子:
int a;
int b = 0;
int myFunc (int a, int b) { return a + b; }
struct _tagExample example;
看到答案。
宣言
声明告诉编译器a 程序元素或名称存在。一个 声明引入一个或多个 命名到程序中。声明可以 在一个程序中出现一次以上。 因此，类，结构， 枚举类型等 用户定义的类型可以声明为 每个编译单元。
定义
定义指定哪些代码或数据 名称描述。名称必须为 在使用之前声明。
声明引入标识符并描述其类型，可以是类型、对象或函数。声明是编译器接受对该标识符的引用所需要的。这些是声明:
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
定义实际上实例化/实现了这个标识符。它是链接器为了将引用链接到这些实体所需要的。这些是对应于上述声明的定义:
int bar;
int g(int lhs, int rhs) {return lhs*rhs;}
double f(int i, double d) {return i+d;}
class foo {};
定义可以用在声明的地方。
标识符可以根据需要任意声明。因此，以下代码在C和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);
但是，它必须只定义一次。如果您忘记定义某个已经声明和引用的东西，那么链接器就不知道要链接到什么地方，并抱怨缺少符号。如果定义一个东西不止一次，那么链接器就不知道要链接引用哪个定义，并抱怨重复的符号。
由于在c++中什么是类声明和类定义的争论不断出现(在对其他问题的回答和评论中)，我将在这里粘贴一段来自c++标准的引用。 在3.1/2,c++ 03说:
声明是定义，除非它[…是类名声明[…]。
3.1/3然后给出了几个例子。其中:
[Example: [...]
struct S { int a; int b; }; // defines S, S::a, and S::b [...]
struct S; // declares S
—end example
总结一下:c++标准考虑结构体x;是一个声明和结构x {};一个定义。(换句话说，“前向声明”是用词不当，因为在c++中没有其他形式的类声明。)
感谢litb (Johannes Schaub)在他的回答中找出了实际的章节和诗句。
c++标准3.1节:
声明将名称引入到翻译单元中，或者重新声明前一个翻译单元中引入的名称 声明。声明指定这些名称的解释和属性。
下一段声明(强调是我的)声明是一种定义，除非……
．.． 它声明一个函数而不指定函数体:
void sqrt(double); // declares sqrt
．.． 它在类定义中声明一个静态成员:
struct X
{
int a; // defines a
static int b; // declares b
};
．.． 它声明了一个类名:
class Y;
．.． 它包含没有初始化式或函数体的extern关键字:
extern const int i = 0; // defines i
extern int j; // declares j
extern "C"
{
void foo(); // declares foo
}
．.． Or是类型定义或using语句。
typedef long LONG_32; // declares LONG_32
using namespace std; // declares std
现在，理解声明和定义之间的区别很重要的一个重要原因是:一个定义规则。c++标准第3.2.1节:
任何翻译单元都不能包含任何变量、函数、类类型、枚举类型或模板的多个定义。
从C99标准，6.7(5):
声明指定一组标识符的解释和属性。标识符的定义是该标识符的声明:
对于一个对象，使存储空间为该对象保留; 对于函数，包括函数体; 类的(唯一)声明 标识符。
来自c++标准3.1(2):
声明是定义，除非它声明了一个函数而没有指定函数体，它包含extern说明符或链接规范，但既没有初始化式也没有函数体，它在类声明中声明了静态数据成员，它是类名声明，或者它是typedef声明，using-declaration，或using-directive。
下面是一些例子。
有趣的是(也许不是，但我有点惊讶)typedef int myint;是C99中的定义，但在c++中只是声明。
你不能用最一般的术语说，声明是一个没有分配存储空间的标识符，而定义实际上是从声明的标识符分配存储空间吗?
一个有趣的想法是:只有类或函数与类型信息链接起来，模板才能分配存储空间。那么模板标识符是声明还是定义呢?它应该是一个声明，因为没有分配存储空间，您只是在对模板类或函数进行“原型化”。
c++中有一些有趣的边缘情况(在C中也有一些)。考虑
T t;
它可以是一个定义，也可以是一个声明，取决于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".
在c++中，当使用模板时，还有另一种边缘情况。
template <typename T>
struct X {
static int member; // declaration
};
template<typename T>
int X<T>::member; // definition
template<>
int X<bool>::member; // declaration!
最后一个声明不是定义。它声明了X<bool>的静态成员的显式特化。它告诉编译器:“如果要实例化X<bool>::member，那么不要从主模板实例化成员的定义，而是使用在其他地方找到的定义”。要使其成为定义，必须提供初始化式
template<>
int X<bool>::member = 1; // definition, belongs into a .cpp file.
定义意味着实际编写的函数，声明意味着简单的声明函数 如。
void myfunction(); //this is simple declaration
and
void myfunction()
{
some statement;
}
这是函数myfunction的定义
声明意味着给变量命名和类型(在变量声明的情况下)，例如:
int i;
或者将名称、返回类型和参数类型赋给一个没有函数体的函数(在函数声明的情况下)，例如:
int max(int, int);
而定义意味着给变量赋值(在变量定义的情况下)，例如:
i = 20;
或者为函数提供/添加函数体(功能)被称为函数定义，例如:
int max(int a, int b)
{
if(a>b) return a;
return b;
}
许多时间声明和定义可以一起完成:
int i=20;
and:
int max(int a, int b)
{
if(a>b) return a;
return b;
}
在上述情况下，我们定义并声明变量i和函数max()。
c++ 11更新
由于我没有看到与c++ 11相关的答案，这里有一个。
声明是定义，除非声明了/n:
opaque enum - enum X: int; 模板参数-模板参数- MyArray 参数声明- x和y在int add(int x, int y); 别名声明-使用IntVector = std::vector<int>; - static_assert(sizeof(int) == 4， "Yikes!") 属性声明(实现定义的) 空声明;
以上列表从c++ 03继承的附加子句:
函数声明- add in int add(int x, int y); Extern说明符包含声明或链接说明符- Extern int a;或extern "C"{…}; 类中的静态数据成员-类C中的x{静态int x;}; 类/struct声明- struct Point; typedef int int; 使用声明-使用std::cout; 使用命名空间NS;
模板声明是一种声明。如果模板声明定义了函数、类或静态数据成员，那么模板声明也是定义。
以下例子来自于区分声明和定义的标准，我发现这些例子有助于理解它们之间的细微差别:
// 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
这听起来很俗气，但这是我能把这些条款直接记在脑子里的最好方法:
宣言:想象托马斯·杰斐逊发表演讲……“我在此声明这个foo在这个源代码中存在!!”
定义:想象一本字典，你正在查找Foo和它的实际意思。
在这里找到类似的答案:C语言的技术面试问题。
声明为程序提供了一个名称;定义提供程序中实体(例如类型、实例和函数)的唯一描述。声明可以在给定的作用域中重复，它在给定的作用域中引入一个名称。
声明是定义，除非:
声明声明了一个函数，但没有指定函数体， 声明包含一个extern说明符，没有初始化式或函数体， 声明是没有类定义的静态类数据成员的声明， 声明是类名定义，
定义是声明，除非:
定义定义一个静态类数据成员， Definition定义一个非内联成员函数。
当您使用extern存储类时，声明和定义的概念将形成一个陷阱，因为您的定义将位于其他位置，而您是在本地代码文件(页面)中声明变量。C和c++之间的一个区别是，在C中，声明通常在函数或代码页的开头完成。在c++中不是这样的。你可以在你选择的地方申报。
我最喜欢的例子是int Num = 5这里你的变量是1。定义为int 2。声明为Num和3。实例化值为5。我们
定义对象的类型，可以是内置的，也可以是类或结构。 声明一个对象的名字，这样任何有名字的东西都被声明了，包括变量、函数等。
类或结构允许您在以后使用时更改对象的定义方式。例如
可以声明没有特别定义的异构变量或数组。 在c++中使用偏移量可以定义一个没有声明名称的对象。
当我们学习编程时，这两个术语经常被混淆，因为我们经常同时做这两个。
定义:
extern int a; // Declaration
int a; // Definition
a = 10 // Initialization
int 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);
}
其中，print函数也被声明和定义。因为函数调用在定义之后。现在看下一个节目。
项目2
#include <stdio.h>
void print(int a); // In this case this is essential
main()
{
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 # 0x400a20
movsd %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 # 0x400a20
movsd %xmm0,-0x8(%rbp)
正如你所看到的，没有任何变化。
声明与定义不同，因为声明提供的信息仅供编译器使用。例如uint8_t告诉编译器使用asm函数movb。
看到:
uint def; | no instructions
printf("some stuff..."); | [...] callq 0x400450 <printf@plt>
def=5; | movb $0x5,-0x45(%rbp)
声明没有等价的指令，因为它不是要执行的东西。
此外，声明告诉编译器变量的作用域。
我们可以说，声明是编译器用来确定正确使用变量的信息，以及某些内存属于某个变量多长时间。
为了理解名词，我们先来看看动词。
声明- - - - - - 宣布:正式宣布;宣告
定义- - - - - - 清晰完整地显示或描述(某人或某事
所以，当你声明某物时，你只需告诉它是什么。
// declaration
int sum(int, int);
这一行声明了一个名为sum的C函数，它接受两个int类型的参数并返回一个int。但是，您还不能使用它。
当你提供它的实际工作方式时，这就是它的定义。
// definition
int 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)链接器
在第二阶段(译者/编译器)，我们代码中的声明语句告诉编译器，这些东西我们将在未来使用，你可以稍后找到定义，意思是:
译者确定:什么是什么?方法声明
(3)阶段(链接器)需要定义来绑定事物
链接器确定:哪里是什么?方法定义
《K&R》(第二版)中有一些非常明确的定义;这有助于把它们放在一个地方，并作为一个整体来阅读:
"Definition" refers to the place where the variable is created or assigned storage; "declaration" refers to the places where the nature of the variable is stated but no storage is allocated. [p. 33] ... It is important to distinguish between the declaration of an external variable and its definition. A declaration announces the properties of a variable (primarily its type); a definition also causes storage to be set aside. If the lines int sp; double val[MAXVAL] appear outside of any function, they define the external variables sp and val, cause storage to be set aside, and also serve as the declaration for the rest of that source file. On the other hand, the lines extern int sp; extern double val[]; declare for the rest of the source file that sp is an int and that val is a double array (whose size is determined elsewhere), but they do not create the variables or reserve storage for them. There must be only one definition of an external variable among all the files that make up the source program. ... Array sizes must be specified with the definition, but are optional with an extern declaration. [pp. 80-81] ... Declarations specify the interpretation given to each identifier; they do not necessarily reserve storage associated with the identifier. Declarations that reserve storage are called definitions. [p. 210]
声明是在未分配值或对象的情况下创建原语或对象引用变量或方法。 int; Final int a;
定义意味着分别为值或对象赋值 Int a =10;
初始化意味着为各个变量或对象分配内存。
变量的声明是为了通知编译器以下信息:变量的名称，它持有的值的类型和初始值(如果有的话)。也就是说，声明给出了关于变量属性的详细信息。然而，变量的定义说的是变量存储在哪里。也就是说，变量的内存是在定义变量时分配的。
从c++标准文档中添加定义和声明示例(来自3.1节声明和定义)
定义:
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
声明:
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 d
声明说"这个东西存在于某个地方"
int sampleFunc(); // function
extern int car; // variable
定义说，这个东西存在于这里;为它留下记忆"
int sampleFunc() {} // function
int car; // variable
在定义对象时，初始化是可选的，并表示“这是这个东西的初始值”:
int car = 0; // variable
