你不能用最一般的术语说，声明是一个没有分配存储空间的标识符，而定义实际上是从声明的标识符分配存储空间吗?

一个有趣的想法是:只有类或函数与类型信息链接起来，模板才能分配存储空间。那么模板标识符是声明还是定义呢?它应该是一个声明，因为没有分配存储空间，您只是在对模板类或函数进行“原型化”。

声明意味着给变量命名和类型(在变量声明的情况下)，例如:

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

可执行文件的生成阶段:

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

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

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

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

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

从C99标准，6.7(5):

声明指定一组标识符的解释和属性。标识符的定义是该标识符的声明:

对于一个对象，使存储空间为该对象保留; 对于函数，包括函数体; 类的(唯一)声明 标识符。

来自c++标准3.1(2):

声明是定义，除非它声明了一个函数而没有指定函数体，它包含extern说明符或链接规范，但既没有初始化式也没有函数体，它在类声明中声明了静态数据成员，它是类名声明，或者它是typedef声明，using-declaration，或using-directive。

下面是一些例子。

有趣的是(也许不是，但我有点惊讶)typedef int myint;是C99中的定义，但在c++中只是声明。

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

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

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