C++Primer——第七章(类)

• 构造函数放在类的public部分。
• 不同于其他成员函数，构造函数不能被声明成const的。（当我们创建类的一个const对象时，直到构造函数完成初始化过程，对象才能真正取得其“常量”属性。因此，构造函数在const对象的构造过程中可以向其写值）

• 编译器只有在发现 类不包含任何构造函数的情况下 才会替我们生成一个默认的构造函数。一旦我们定义了一些其他的构造函数，那么除非我们再定义 一个默认的构造函数，否则类将没有默认构造函数。
• 对于某些类来说，合成的默认构造函数可能执行错误的操作。例如：如果定义在块中的 内置类型或复合类型(比如数组和指针)的对象 被默认初始化，则它们的值将是 未定义的。
• 有的时候编译器不能为某些类 合成默认的构造函数。例如：如果类中包含一个其他类类型的成员 且这个成员的类型没有默认构造函数，那么编译器将 无法初始化该成员。对于这样的类来说，我们必须自定义默认构造函数，否则该类将没有可用的默认构造函数。

• 友元的声明仅仅指定了 访问的权限，而非一个通常意义上的函数声明。
• 友元关系不存在传递性。（朋友的朋友不一定是我的朋友）

7.3 类的其他特性

1. 在类内部定义。
2. 在类外部定义，但显示的加上inline关键字。

class A {
public:
    A fun();

private:
    typedef A A_t;
};

A::A_t A::fun( ) {     // A_t前面必须有(A::)，作用域运算符A::后面的语句块才在作用域内，如果A_t之前没有(A::)，就不在作用域内

}

typedef int int_t;

class A {
public:
    int_t fun();

private:
    typedef double int_t;     // 错误: 即使A中定义的int_t类型 与外层作用域定义的int_t一致， 但仍然是错误的（甚至有的编译器不报错）
    int_t a;
};

• 当我们在块作用域内 不使用任何初始值定义一个 非静态变量或者数组时。
• 当一个类本身含有类类型的成员 且使用合成的默认构造函数时。
• 当类类型的成员 没有在构造函数初始值列表中 显式地初始化时。

• 在数组初始化的过程中 如果我们提供的初始值数量 小于数组的大小时。
• 当我们不使用初始值 定义一个局部静态变量时。
• 当我们通过书写形如T( )的表达式显式地请求值初始化时，其中T是类型名。

隐式的类型转换：

class Demo {
public:
    Demo(string str, int i) :a(str), b(i) { }
    Demo(string str) :a(str), b(0) { }

    string combine_a(const Demo& demo) {     // 参数是const Demo&类型
        return a + demo.a;
    }

private:
    string a;
    int b;
};

int main() {
    string str1 = "aaa", str2 = "bbb";

    Demo A(str1,1);     // a="aaa",b=1
    string result = A.combine_a(str2);      // result="aaabbb" (传递str2将会先调用 构造函数Demo(string i)，从而转换为Demo类型对象，再调用combine_a函数)
}

// 将上列str2改为"bbb"
string result = A.combine_a("bbb");     // 错误：不存在从 cosnt char[4] 到 Demo 的适当构造函数（"bbb"不会先转换到string，再转换到Demo）

// 将上例中的Demo定义成expilic
explicit Demo(string str) :a(str), b(0) { cout << a << b << endl; } 

string result = A.combine_a(str2);      // 错误: 此时不可以调用Demo(string str)构造函数 将string类型的str2转换为Demo类型对象

explicit Demo(string str) :a(str),b(0) {}

Demo A(str1);       // 正确: 直接初始化
Demo B = str1;      // 错误: 不能将 explicit构造函数 用于拷贝形式的初始化过程 

explicit Demo(string str) :a(str), b(0) { }

A.combine_a(str2);                  // 错误: Demo(string str)为exlicit构造函数，无法隐式调用进行类型转换
A.combine_a(Demo(str2));            // 正确: 显式调用Demo(string str)进行类型转换
A.combine_a(static_cast(str2))      // 正确: static_cast可以使用 explicit构造函数

• 所有成员都是public的。
• 没有定义任何构造函数。
• 没有类内初始值。
• 没有基类，也没有virtual函数。

// 聚合类示例:
struct Data {
    int val;
    string s;
};

class person {
public:
    int id;
    string name;
};

int main() {
    Data data1 = { 0,"aaa" };       // 正确
    Data data2 = { "aaa",0 };       // 错误: 不能使用"aaa"初始化val

    person per1 = { 123,"bob" };    // 正确
    person per2 = { 456 };          // 正确: name默认初始化为""
}

字面值常量类：

• 数据成员都必须是字面值类型。
• 类必须至少含有一个constexpr构造函数。（constexpr函数的参数和返回值必须是字面值。）
• 如果一个数据成员含有 类内部初始值，则内置类型成员的初始值 必须是一条常量表达式；或者如果成员属于某种 类类型，则初始值必须使用 成员自己的constexpr构造函数。
• 类必须使用 析构函数的默认定义，该成员负责销毁类的对象。

• 通过前置constexpr关键字，就可以声明constexpr构造函数。
• 除了声明为=default或者=delete以外，constexpr构造函数的函数体一般为空。（综合 构造函数没有返回值 且 constexpr函数唯一可执行语句为返回语句，可知constexpr构造函数体一般为空）
• constexpr构造函数必须 初始化所有数据成员，初始值或者使用constexpr构造函数，或者是一条常量表达式。
• constexpr构造函数用于生成 constexpr对象、constexpr函数的参数或返回类型。

struct Point {
    constexpr Point(int i, int j): x(i), y(j) {}
    constexpr Point(): Point(0, 0) {}
    int x;
    int y;
};

int main() {
    constexpr Point pt1 = { 1,1 };    
    constexpr Point pt2(2, 2);
}
// 这样声明以后，就可以在使用 constexpr表达式或者constexpr函数的地方 使用字面值常量类了。

7.6 类的静态成员

struct Demo {
private:
    static const int a1;                  // 正确
    static const int a2 = 1;              // 正确: const静态整数类型成员 可以类内初始化
    static const double b1;               // 正确
    static const double b2 = 1.1;         // 错误: static const double 不能类内初始化
    static constexpr double c1;           // 错误: constexpr静态数据成员必须初始化
    static constexpr double c2= 3.14;     // 正确
};

• 静态数据成员的类型可以就是 它所属的类类型。而非静态数据成员则受到限制，只能声明成 它所属类的指针或引用
• 可以使用静态成员作为默认实参

struct Demo {
public:
    void fun(Demo demo= a) {}    // 正确: 静态成员可以作为默认实参，因为静态成员不属于对象
    void fun(int i = m) {}       // 错误: 非静态类型不能作为默认实参，因为它的值本身属于对象一部分

private:
    int m = 5;

    static Demo a;     // 正确: 静态成员可以是不完全类型
    Demo* b;           // 正确: 指针成员可以是不完全类型
    Demo c;            // 错误：数据成员必须是完全类型（而这里Demo是一个不完全类型，因为定义体未完成）
};