编程语言

img lynnboy

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

发表于2004/11/1 2:32:00  1344人阅读

分类: ISO/IEC 14882:1998

请不要转载本文;请不要以任何形式重新出版,发布本文;请在下载本文 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】
阅读全文
0 0

相关文章推荐

img
取 消
img