初始化列表，static成员，友元，匿名对象，拷贝构造的优化

目录

1.构造函数加强理解

a.初始化列表

b.explicit关键字

2.static成员

3.友元

4.匿名对象

5.拷贝函数的编译器优化

---

1.构造函数加强理解

我们对于构造函数除了我们自己写的构造函数，和默认构造函数之外，还有一种我们不写自动生成的构造函数，我们之前说到这种构造函数会自己去对我们的自定义构造函数进行初始化；但是这个初始化的地方在哪里呢？到底如何去调用我们自定义类型成员它的构造函数呢？

a.初始化列表

我们会在我们构造函数的括号后方进行列表初始化，这个地方会进行我们自定义类型成员变量的初始化，我们会在这个地方调用我们自定义类型成员它的构造函数来初始化它，这就是我们不写的默认构造函数的作用——调用我们的成员变量的构造函数；当然我们的初始化列表不仅仅只有这么一点点作用，它还可以初始化我们所有的成员（除去静态变量之外）变量；如何写列表初始化呢？

初始化列表：以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个"成员变量"后面跟 一个放在括号中的初始值或表达式。

class Date
{
public:
Date(int year, int month, int day)
     : _year(year)
     , _month(month)
     , _day(day)
 {}
private:
int _year;
int _month;
int _day;
};

我们的列表初始化一定会自动对我们的自定义类型进行初始化的；并且我们所有的成员变量（除去静态成员变量）都是在列表初始化的时候定义的；我们有三类成员变量一定要在列表初始化时或者C++11补丁处初始化：

1.引用成员变量

2.const修饰的成员变量

3.自定义类型成员变量（它没有默认构造函数的时候）

我们的初始化也是有顺序的：

我们会根据我们的声明顺序来初始化化我们的成员变量；

b.explicit关键字

构造函数不仅可以构造与初始化对象，对于单个参数或者除第一个参数无默认值其余均有默认值 的构造函数，还具有类型转换的作用。所以我们传递的参数为单参时会进行隐式类型的转换；

我们的explicit关键字就起到了阻止类型转换的作用；

我们写如下代码：

class Date
{
public:

 //explicit Date(int year)会报错
 Date(int year)
 :_year(year)
 {}
 explicit Date(int year, int month = 1, int day = 1)
 : _year(year)
 , _month(month)
 , _day(day)
 {}
 Date& operator=(const Date& d)
 {
 if (this != &d)
 {
 _year = d._year;
 _month = d._month;
 _day = d._day;
 }
 return *this;
 }
private:
 int _year;
 int _month;
 int _day;
};
void Test()
{
 Date d1(2022);

 d1 = 2023;
}

2023想要变成d1的话那他需要进行隐式的类型转换，他就需要调用构造函数创建一个Date类型的临时变量，但如果我们加上了explicit关键字的话就会导致我们的2023传递无法进行类型转换，所以程序就会报错；

优化：我们编译器在这里其实对我们的这一操作进行了优化使得我们2023直接进行构造函数给了d1省去了拷贝构造的过程；

2.static成员

static成员就是我们前面提到的例外不在初始化列表定义的例外，它是在我们类外面定义，初始化的成员变量，它是属于所有类对象的，所有的类对象都包含它；

特性：

1.我们的静态成员变量是属于所有的类对象的，它储存的位置在静态区

我们a种的两个int成员的大小就有了8个字节但是我们里面还拥有一个静态成员变量；所以说明我们静态变量不储存在类对象中；

 2.类对象只能定义在我们的类外面，类里面的只是声明，我们从上面那条就可以明白为什么初始化列表初始不了我们的静态变量了因为它储存在我们的静态区，所以定义也需要定义在外面；

3.静态成员函数是没有this指针的所以它访问不了我们的非静态成员变量；所以它也调用不了我们的成员函数；

4.我们可以用类名来直接访问我的静态成员，不需要创建变量在访问，这样十分的方便；

5.静态成员也是会受到我们的访问限定符限制的；

3.友元

当我们在类的外面并且我们不是类的成员，但我们像访问类的私有成员时我们就可以使用友元来访问；比如我们在类外写了一个函数我需要用到类里面的私有的成员变量，那么我就可以在类中声明；

class Date
{
 friend ostream& operator<<(ostream& _cout, const Date& d);
 friend istream& operator>>(istream& _cin, Date& d);
public:
 Date(int year = 1900, int month = 1, int day = 1)
 : _year(year)
 , _month(month)
 , _day(day)
 {}
private:
 int _year;
 int _month;
 int _day;
};
ostream& operator<<(ostream& _cout, const Date& d)
{
 _cout << d._year << "-" << d._month << "-" << d._day;
 return _cout; 
}
istream& operator>>(istream& _cin, Date& d)
{
 _cin >> d._year;
 _cin >> d._month;
 _cin >> d._day;
 return _cin;
}
int main()
{
 Date d;
 cin >> d;
 cout << d << endl;
 return 0;
}

上面我们使用操作符重载重载了<<与>>，因为我们需要把左操作数写成cin和cout所以只好把这个重载函数写到类的外面，但是我们还是需要调用类对象它的成员变量所以我们就在类中写这个重载函数是我们类的友元的声明并在前面加上friend操作符就好啦；

特点：

1.我们的友元函数不属于任何类所以它不具备成员函数的特点！

2.友元函数不能被const修饰（因为它不是成员函数没有this指针）

3.友元函数可以在类的任何地方声明它不受类访问限定符的限制；

4.友元函数的调用和普通函数的调用原理相同；

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

友元类

和友元一样也就是在类前面加上一个friend，写成friend class XXX；

1.一个类也可以是另一个类的友元，我们叫这个类叫友元类，这个类可以调用我们另一个类的所以成员；

2.友元类是没有传递性的比如b是a的友元，c是b的友元，不能说明c是a的友元

3.友元关系是不能继承的；

内部类

我们可以把一个类写到另一个类的内部这样我们的这个类就是另一个类的内部类了；

内部类和友元类类似，就把内部类看成是友元类就好了，只是写的地方不太一样，并且它受到外部类的限制访问，需要通过外部类来访问；

4.匿名对象

我们可以创建一个没有名字的对象这个对象的生命周期很短只有一行，这行结束了它就会被销毁，我们可以使用它来调用一些类的成员这样我们就不需要先创建一个对象再去使用这对象来调用我们这个类里面的成员了；下面是例子；

class A
{
public:
 A(int a = 0)
 :_a(a)
 {
 cout << "A(int a)" << endl;
 }
 ~A()
 {
 cout << "~A()" << endl;
 }
private:
 int _a;
};
class Solution {
public:
 int Sum_Solution(int n) {
 //...
 return n;
 }
};
int main()
{
 A aa1;
 // 不能这么定义对象，因为编译器无法识别下面是一个函数声明，还是对象定义
 //A aa1();
 // 但是我们可以这么定义匿名对象，匿名对象的特点不用取名字，
 // 但是他的生命周期只有这一行，我们可以看到下一行他就会自动调用析构函数
 A();
 A aa2(2);
 Solution().Sum_Solution(10);//在此场景下使用
 return 0;
}

5.拷贝函数的编译器优化

我们的编译器在一些连续赋值的地方会进行优化；把临时变量的传递优化了，没有了临时变量；如果优化程度在提升会把所以的中间没有使用的变量全部优化掉，那些拷贝构造都会消失，优化程度是根据编译器来定的；(连续的构造相同类型的拷贝才能优化，如果是不同类型则不能这么优化，如拷贝构造和赋值拷贝这两个在一起不能优化，因为它们是不同类型的)；

2023.6.2——2023.6.2