3.1 - [basic.def] - 【基本.定义】

请不要转载本文；请不要以任何形式重新出版，发布本文；请在下载本文 24 小时内将其删除；禁止将本文用于商业目的。

3 Basic concepts [basic] 3.1 Declarations and definitions [basic.def]	3 基本概念 【基本】 3.1 声明和定义 【基本.定义】
A declaration (clause 7) introduces names into a translation unit or redeclares names introduced by previous declarations. A declaration specifies the interpretation and attributes of these names.	声明（章节 7）向翻译单元引入名字，或重新声明之前声明的名字。声明指定了这些名字的解释和性质。
A declaration is a definition unless it declares a function without specifying the function's body (8.4), it contains the extern specifier (7.1.1) or a linkage-specification24) (7.5) and neither an initializer nor a function-body, it declares a static data member in a class declaration (9.4), it is a class name declaration (9.1), or it is a typedef declaration (7.1.3), a using-declaration (7.3.3), or a using-directive (7.3.4).	声明就是定义，除非其声明函数但没有指定函数体（8.4），其包含 extern 限定词（7.1.1）或连接性规范24)（7.5）但没有初始化符或函数体，其在类声明（9.4）中声明静态数据成员，其为一个类名声明（9.1），或其为 typedef 声明（7.1.3），using-声明（7.3.3），或 using-指令（7.3.4）。
[Example: all but one of the following 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 nonstatic 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 whereas these are just 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 --end example]	【例：下面除了一个全都是定义：     int a;                          // 定义 a     extern const int c = 1;         // 定义 c     int f(int x) { return x+a; }    // 定义 f 并定义 x     struct S { int a; int b; };     // 定义 S, S::a, 和 S::b     struct X {                      // 定义 X         int x;                      // 定义非静态数据成员 x         static int y;               // 声明静态数据成员 y         X(): x(0) { }               // 定义 X 的一个构造函数     };     int X::y = 1;                   // 定义 X::y     enum { up, down };              // 定义 up and down     namespace N { int d; }          // 定义 N and N::d     namespace N1 = N;               // 定义 N1     X anX;                          // 定义 anX 然而这些只是声明：     extern int a;                   // 声明 a     extern const int c;             // 声明 c     int f(int);                     // 声明 f     struct S;                       // 声明 S     typedef int Int;                // 声明 Int     extern X anotherX;              // 声明 anotherX     using N::d;                     // 声明 N::d --例完】
[Note: in some circumstances, C++ implementations implicitly define the default constructor (12.1), copy constructor (12.8), assignment operator (12.8), or destructor (12.4) member functions. [Example: given     struct C {         string s;                 // string is the standard library class (clause 21)      };     int main()     {         C a;         C b = a;         b = a;     } the implementation will implicitly define functions to make the definition of C equivalent to     struct C {         string s;         C(): s() { }         C(const C& x): s(x.s) { }         C& operator=(const C& x) { s = x.s; return *this; }         ~C() { }     }; --end example] --end note]	【注：某些情况下，C++ 实现隐含地定义默认构造（12.1），复制构造（12.8），复制运算符，或析构（12.4）成员函数。【例：给定     struct C {         string s;                 // string 是标准库类（章节 21）     };     int main()     {         C a;         C b = a;         b = a;     } 实现将隐含地定义函数以使 C 的定义等价于     struct C {         string s;         C(): s() { }         C(const C& x): s(x.s) { }         C& operator=(const C& x) { s = x.s; return *this; }         ~C() { }     }; --例完】 --注完】
[Note: a class name can also be implicitly declared by an elaborated-type-specifier (3.3.1).]	【注：类名也可能被详细类型限定符（3.3.1）隐含地声明。】
A program is ill-formed if the definition of any object gives the object an incomplete type (3.9).	如果任何对象的定义为对象指定不完整的类型（3.9），则程序是病态形式的。
24) Appearing inside the braced-enclosed declaration-seq in a linkage-specification does not affect whether a declaration is a definition.	24) 连接性规范以花括号包围的声明序列中的声明是否是定义不受影响。
PREV [basic] | NEXT [basic.def.odr]	上一页 【基本】 | 下一页 【基本.定义.ODR】