C++ 类和对象：构造函数细节、静态成员、友元函数及编译器优化

结果为 1 1 1，答案正确，这就是初始化列表啦。

静态成员

1. 用 static 修饰的成员变量叫静态成员变量，静态成员变量一定要在类外面初始化。因为类独属一个域，静态成员变量在静态区，所以要在类外面初始化。
2. 静态成员变量为所有类对象共享，不属于任何一个具体的对象。
3. 静态成员函数没有 this 指针。
4. 静态成员函数可以访问其他的静态成员，但不能访问非静态的，因为没有 this 指针。
5. 非静态的成员函数，可以访问任意的静态成员变量和函数。
6. 访问静态成员要突破类域，也就是类似于命名空间的类名::静态成员或对象名。静态成员来访问。
7. 静态成员受访问限定符限制。
8. 静态成员变量不能在声明位置初始化，因为它不属于任何一个对象。

#include <iostream>
using namespace std;

class D1 {
public:
    D1(int year = 1, int month = 1, int day = 1) :_year(year), _month(month), _day(day) { }
    void print() const { cout << _year << " " << _month << " " << _day << endl; }
private:
    int _year;
    int _day;
    int _month;
    static int person; // 需要在类外初始化
};

int D1::person = 1; // 初始化记得带上类名

int main() {
    D1 a;
    a.print();
    return 0;
}

友元函数

1. 友元是突破类域的一种方式，友元分为：友元函数和友元类。使用方式是在函数声明或者类声明前面加 friend，还要把友元的声明放到一个类中。
2. 外部友元函数可以访问类的私有和保护成员，它是一个声明，并不是类的成员函数。可以理解为非常好的朋友，你对我干什么都可以。
3. 友元可以在类中任意位置定义。
4. 一个函数可以是多个类的友元。
5. 友元类中的成员函数都可以是另一个类的友元函数。
6. 友元类的关系是单向的。我的友元函数是你，意味着你可以随意用我东西，但是我不能随意用你东西。
7. 偶尔方便可以使用，但它会增加耦合度，破坏封装。

#include <iostream>
using namespace std;

class B; // 必须有前置声明，否则 A 都不认识 B，代码从上往下执行。
class A {
    friend void print(const A& aa, const B& bb); // 定义 aa 代替传进来的类变量，bb 代替第二个类变量
private:
    int _a1 = 11;
    int _a2 = 22;
};

class B {
    friend void print(const A& aa, const B& bb); // 定义 aa 代替传进来的类变量，bb 代替第二个类变量
private:
    int _b1 = 111;
    int _b2 = 222;
};

void print(const A& aa, const B& bb) { // 定义 aa 代替传进来的类变量，bb 代替第二个类变量
    cout << aa._a1 << endl;
    cout << bb._b1 << endl;
}

int main() {
    A a;
    B b;
    print(a, b);
    return 0;
}

#include <iostream>
using namespace std;

class A {
    friend class B;
private:
    int _a1 = 11;
    int _a2 = 22;
};

class B {
public:
    void print(const A& aa) { // 定义 aa 代替传进来的类变量，因为 A 是 B 的友元，所以 B 可以访问 A 的成员变量
        cout << aa._a1 << endl;
        cout << _b1 << endl;
    }
private:
    int _b1 = 111;
    int _b2 = 222;
};

int main() {
    A a;
    B b;
    b.print(a);
    return 0;
}

编译器优化

1. 编译器日新月异，在提高版本的过程中进行了一系列的优化，在不影响结果的情况下，会减少部分传参和传值的拷贝构造。
2. 编译器的不同会进行不同的优化，连续的拷贝构造会合并成一个拷贝构造。
3. 想看具体过程有两个办法，一是在 Linux 下关闭构造优化，命令为 g++ test.cpp -fno-elide-constructors；二是使用较老的编译器，这时候都没有进行更新，也就没有优化的概念。

#include <iostream>
using namespace std;

class A {
public:
    A(int a = 1) :_a1(a) { cout << "A(int a)" << endl; }
    A(const A& aa) :_a1(aa._a1) // 拷贝构造的初始化列表
    {
        cout << "A(const A& aa)" << endl;
    }
    ~A() { cout << "~A()" << endl; }
private:
    int _a1 = 11;
};

void f1(A aa) { }

int main() {
    // 匿名对象，也就是直接给 A 赋值，生命周期只有这一行，构造一次，函数内右构造一次还要拷贝一次，然后析构
    f1(A(1)); // 连续的构造加拷贝构造会优化为一个构造
    return 0;
}