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节:

任何翻译单元都不能包含任何变量、函数、类类型、枚举类型或模板的多个定义。

宣言

声明告诉编译器a 程序元素或名称存在。一个 声明引入一个或多个 命名到程序中。声明可以 在一个程序中出现一次以上。 因此，类，结构， 枚举类型等 用户定义的类型可以声明为 每个编译单元。

定义

定义指定哪些代码或数据 名称描述。名称必须为 在使用之前声明。

在这里找到类似的答案:C语言的技术面试问题。

声明为程序提供了一个名称;定义提供程序中实体(例如类型、实例和函数)的唯一描述。声明可以在给定的作用域中重复，它在给定的作用域中引入一个名称。

声明是定义，除非:

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

定义是声明，除非:

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

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

从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; 

看到答案。

可执行文件的生成阶段:

(1)预处理器->(2)转换器/编译器->(3)链接器

在第二阶段(译者/编译器)，我们代码中的声明语句告诉编译器，这些东西我们将在未来使用，你可以稍后找到定义，意思是:

译者确定:什么是什么?方法声明

(3)阶段(链接器)需要定义来绑定事物

链接器确定:哪里是什么?方法定义