构造函数初始化列表-优快云博客

本文链接：https://blog.youkuaiyun.com/2302_76591114/article/details/145701767

一、初始化列表

二、类型转换

一、初始化列表

以往初始化成员变量，我们常使用函数体内赋值。其实，还有一种更高效、更规范的方式 —— 初始化列表。初始化列表以冒号起始，后跟逗号分隔的成员变量列表，每个成员变量后是括号中的初始值或表达式。像引用成员变量、const 成员变量以及没有默认构造的类类型变量，必须在初始化列表中初始化，否则会编译报错。

C++11 允许在成员变量声明处给缺省值，这个缺省值用于未在初始化列表中显式初始化的成员。这里有个小技巧，尽量使用初始化列表初始化，因为就算不在初始化列表里初始化的成员，也会走初始化列表的流程。如果成员声明处有缺省值，初始化列表就用这个值初始化；要是没有缺省值，内置类型成员是否初始化就取决于编译器了，而自定义类型成员会调用其默认构造函数，要是没有默认构造函数，那就会编译出错。

class Time {
public:
    Time(int hour) : _hour(hour) {
        cout << "Time()" << endl;
    }
private:
    int _hour;
};

class Date {
public:
    Date(int& x, int year = 1, int month = 1, int day = 1) : _year(year), _month(month), _day(day), _t(12), _ref(x), _n(1) {}
    void Print() const {
        cout << _year << "-" << _month << "-" << _day << endl;
    }
private:
    int _year;
    int _month;
    int _day;
    Time _t;
    int& _ref;
    const int _n;
};

二、类型转换

C++ 支持内置类型隐式转换为类类型对象，前提是有对应的以该内置类型为参数的构造函数。但要是在构造函数前加 explicit 关键字，就禁止了这种隐式转换，让类型转换更加可控。类类型对象之间也能隐式转换，同样需要相应构造函数的支持。

class A {
public:
    A(int a1) : _a1(a1) {}
    void Print() {
        cout << _a1 << endl;
    }
private:
    int _a1 = 1;
};

int main() {
    A aa1 = 1; // 隐式类型转换
    aa1.Print();
    return 0;
}

三、static成员

用static修饰的成员变量是静态成员变量，它为所有类对象共享，不属于某个具体对象，存储在静态区，并且必须在类外初始化。

静态成员函数没有this指针，所以在静态成员函数里只能访问其他静态成员，不能访问非静态成员。

而非静态成员函数则可以随意访问静态成员变量和静态成员函数。

访问静态成员有两种方式，通过类名：：静态成员或者对象.静态成员，同时静态成员也受访问限定符的约束。

class A {
public:
    A() {
        ++_scount;
    }
    A(const A& t) {
        ++_scount;
    }
    ~A() {
        --_scount;
    }
    static int GetACount() {
        return _scount;
    }
private:
    static int _scount;
};

int A::_scount = 0;

int main() {
    cout << A::GetACount() << endl;
    A a1, a2;
    A a3(a1);
    cout << A::GetACount() << endl;
    return 0;
}

四、友元

友元是 C++ 里突破类访问限定符封装的一种机制，分为友元函数和友元类。在函数或类声明前加friend关键字，并把声明放在类里，就能让外部函数或类访问该类的私有和保护成员。

友元函数不是类的成员函数，却能访问类的内部成员，而且它的声明位置很灵活，不受访问限定符的限制。

一个函数可以是多个类的友元函数。

友元类的关系是单向的，也不能传递。

虽然友元提供了便利，但它破坏了封装性，增加了代码耦合度，所以使用时要谨慎。

class B;

class A {
    friend void func(const A& aa, const B& bb);
private:
    int _a1 = 1;
    int _a2 = 2;
};

class B {
    friend void func(const A& aa, const B& bb);
private:
    int _b1 = 3;
    int _b2 = 4;
};

void func(const A& aa, const B& bb) {
    cout << aa._a1 << endl;
    cout << bb._b1 << endl;
}

五、内部类

如果一个类定义在另一个类内部，它就是内部类。内部类是独立的类，只是受外部类的类域和访问限定符限制，外部类对象并不包含内部类对象。内部类默认是外部类的友元类，这在 A 类和 B 类紧密关联，A 类主要为 B 类服务的场景下很有用，比如把 A 类设计为 B 类的内部类，放在private或protected位置，让 A 类成为 B 类的专属内部类。

class A {
private:
    static int _k;
    int _h = 1;
public:
    class B {
    public:
        void foo(const A& a) {
            cout << _k << endl;
            cout << a._h << endl;
        }
    };
};

int A::_k = 1;

int main() {
    A::B b;
    A aa;
    b.foo(aa);
    return 0;
}

六、匿名对象

用类型（实参）定义的对象是匿名对象，和有名对象相比，它的生命周期只在当前行，适用于临时使用对象的场景。比如在调用函数时，直接用匿名对象作为参数，用完就销毁，减少了对象命名和管理的麻烦。

class A {
public:
    A(int a = 0) : _a(a) {
        cout << "A(int a)" << endl;
    }
    ~A() {
        cout << "~A()" << endl;
    }
private:
    int _a;
};

int main() {
    A(1); // 匿名对象
    return 0;
}

七、对象拷贝时编译器优化

现代编译器为了提高程序效率，在不影响正确性的前提下，会对对象拷贝过程进行优化。主流编译器会合并连续拷贝，有些更激进的编译器还能跨行跨表达式优化。不过，C++ 标准没严格规定具体优化方式，不同编译器处理方式有所不同。比如在传值传参和传值返回时，编译器可能会省略一些不必要的拷贝构造。

class A {
public:
    A(int a = 0) : _a1(a) {
        cout << "A(int a)" << endl;
    }
    A(const A& aa) : _a1(aa._a1) {
        cout << "A(const A& aa)" << endl;
    }
    A& operator=(const A& aa) {
        if (this != &aa) {
            _a1 = aa._a1;
        }
        cout << "A& operator=(const A& aa)" << endl;
        return *this;
    }
    ~A() {
        cout << "~A()" << endl;
    }
private:
    int _a1 = 1;
};

void f1(A aa) {}

A f2() {
    A aa;
    return aa;
}

int main() {
    A aa1;
    f1(aa1);
    f1(1); // 隐式类型，连续构造 + 拷贝构造优化为直接构造
    return 0;
}