一、构造函数

构造函数体赋值🐾

❓ 引出初始化列表 ❔

class A
{
public:A(int a = 0){_a = a;	}
private:int _a;
};
class B
{
private:int _b = 1;A _aa;
};
int main()
{B b;return 0;
}

📝 说明

对于 B，我们不写构造函数，编译器会默认生成 —— 内置类型不处理，自定义类型会去调用它的默认构造函数处理 (无参的、全缺省的、编译器默认生成的)，注意无参的和全缺省的只能存在一个，如果写了编译器就不会生成，如果不写编译器会默认生成。这里 C++ 有一个不好的处理 —— 内置类型不处理，自定义类型处理。针对这种问题，在 C++11 又打了一个补丁 —— 在内置类型后可以加上一个缺省值，你不初始化它时，它会使用缺省值初始化。这是 C++ 早期设计的缺陷。

class A
{
public:A(int a = 0){_a = a;	cout << "A(int a = 0)" << endl;}A& operator=(const A& aa)//不写也行，因为这里只有内置类型，默认生成的就可以完成{cout << "A& operator=(const A& aa)" << endl;if(this != &aa){_a = aa._a;}return *this;}
private:int _a;
};
class B
{
public:B(int a, int b){//_aa._a = a;//err:无法访问private成员/*A aa(a);_aa = aa;*/ _aa = A(a);//简化版，同上_b = b;}
private:int _b = 1;A _aa;
};
int main()
{B b(10, 20);return 0;
}

📝 说明

对上，_b只能初始化成1，_a只能初始化成0 ❓

这里可以显示的初始化，利用匿名对象来初始化 _a。

但是这种方法代价较大 (见下图)。

初始化列表🐾

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

class A
{
public:A(int a = 0){_a = a;	cout << "A(int a = 0)" << endl;}A& operator=(const A& aa){cout << "A& operator=(const A& aa)" << endl;if(this != &aa){_a = aa._a;}return *this;}
private:int _a;
};
class B
{
public:B(int a, int b):_aa(a){_b = b;}
private:int _b = 1;A _aa;
};
int main()
{B b(10, 20);return 0;
}

• 可以看到相比于在函数体内初始化，使用初始化列表初始化可以提高效率 —— 注意对于内置类型你使用函数体或初始化列表来初始化没有区别；但是对于自定义类型，使用初始化列表是更具有价值的。这里还要注意的是函数体内初始化和初始化列表是可以混着用的。

什么成员是必须使用初始化列表初始化的 ❓

class A
{
public:A(int a):_a(a){}
private:int _a;
};
class B
{
public:B(int a, int ref):_aobj(a),_ref(ref),_n(10){}
private:A _aobj;//没有默认构造函数int& _ref;//引用const int _n;//const 
};

⚠ 注意

1️⃣ 每个成员变量在初始化列表 (同定义) 中只能出现一次 (初始化只能初始化一次)。

2️⃣ 类中包含以下成员，必须放在初始化列表位置进行初始化：

1、引用成员变量 (引用成员必须在定义的时候初始化)

2、const 成员变量 (const 类型的成员必须在定义的时候初始化)

3、自定义类型成员 (该类没有默认构造函数)

✨ 成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中出现的先后次序无关

#include<iostream>
using namespace std;
class A
{
public:A(int a):_a1(a),_a2(_a1){}void Print(){cout << _a1 << " " << _a2 << endl;	}
private:int _a2;int _a1;
};
int main()
{A aa(1);aa.Print();	
}

📝 说明

上面的程序输出 ❓

A. 1  1

B. 程序崩溃

C. 编译不通过

D. 1  随机值

如上程序的输出结果是D 选项，因为 C++ 规定成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其初始化列表中出现的先后次序无关。实际中，建议声明顺序和初始化列表顺序保持一致，避免出现这样的问题。

💦 explicit关键字

class A
{
public:A(int a)//构造函数:_a(a){cout << "A(int a)" << endl;	}A(const A& aa)//拷贝构造函数{cout << "A(const A& aa)" << endl;	}
private:int _a;
};
int main()
{A aa1(1);A aa2 = 1;return 0;
}

📝 说明

A aa2 = 1; 意思和 A aa1(1)相同; 这是 C++98 支持的语法，它本质上是一个隐式类型转换 ，将 int 转换为 A，为什么 int 能转换成 A 呢 ？ 因为它支持一个用 int 参数去初始化 A 的构造函数。它俩虽然结果是一样的，都是直接调用构造函数，但是对于编译器而言过程不一样（如下）。因此才会调用两次构造函数而不调用拷贝构造函数

❓ 如果不想允许这样的隐式类型转换的发生 ❔

这里可以使用关键字 explicit

class A
{
public:explicit A(int a):_a(a){cout << "A(int a)" << endl;	}
private:
int _a;
};int main()
{A aa2 = 1;return 0;
}
//error C2440: “初始化”: 无法从“int”转换为“A”

❓ 多参数隐式类型转换 ❔

class A
{
public:A(int a1, int a2):_a(a1){cout << "A(int a1, int a2)" << endl;	}A(const A& aa){cout << "A(const A& aa)" << endl;	}
private:int _a;
};
int main()
{A aa1(1, 2);//A aa2 = 1, 2;//errorA aa2 = {1, 2};return 0;
}

📝说明

• A aa2 = 1, 2; 是错误写法， C++98 不支持多参数的隐式类型转换，但是 C++11 是支持的,　A aa2 = {1, 2};同样编译器依然会优化。当我们使用 explicit 关键字限制时，它会 error C2440：“初始化”: 无法从“int”转换为“A”

• 如果你将单参数构造函数改为explicit A(int a)，那么A aa2 = 1;这行代码就会导致编译错误，因为编译器被禁止进行从int到A的隐式类型转换。你必须显式地调用构造函数，像A aa2(1);这样。

• 总的来说，explicit关键字可以帮助你控制类型转换，防止因为不希望的隐式类型转换而导致的错误。

二、static成员🐾

概念

❓ 写一个程序，计算程序构造了多少个对象 (构造+拷贝构造) ❔

int countC = 0;//记录调用构造函数的次数
int countCC = 0;//记录调用拷贝构造函数的次数
class A
{
public:A(){++countC;}A(const A& a){++countCC;}
};
A f(A a)
{A ret(a);return ret;
}
int main()
{A a1 = f(A());A a2;A a3;a3 = f(a2);cout << countC << endl;cout << countCC << endl;return 0;
}

📝说明

这样虽然能计算出结果，但是有一个问题，countC 和 countCC 是可以随便改的，这样就很不好。

优化 ❓

class A
{
public:A(){++_count;}A(const A& a){++_count;}//静态成员函数特点是没有this指针static int GetCount(){return _count;	}
private:int _a;static int _count;//注意静态成员不能给缺省值，使用静态可以保证不同成员函数//++_count是同一个_count,而不是不同的临时变量//_count不是属于某个对象的，而是属于整个类的
};
//定义初始化
int A::_count = 0;
A f(A a)
{A ret(a);return ret;
}
int main()
{A a1 = f(A());A a2;A a3;a3 = f(a2);cout << sizeof(A) << endl;//这里就体现了static成员属于整个类，也属于每个定义出来的对象共享，但限制于公有/*cout << A::_count << endl;	cout << a1._count << endl;cout << a2._count << endl;*//*A ret;cout << ret.GetCount() - 1 << endl;*//*cout << A().GetCount() - 1 << endl;*/cout << A::GetCount() << endl;return 0;
}

📝说明

int _a; 存在定义出的对象中，属于对象。

static int _count; 存在静态区，属于整个类，也属于每个定义出来的对象共享。跟全局变量比较，它受类域和访问限定符限制，更好的体现封装，别人不能轻易修改。

static成员 ❓

对于非 static 成员它们的定义是在初始化列表中，但在 C++ 中，static 静态成员变量是不能在类的内部定义初始化的，这里的内部只是声明。注意这里虽然是私有成员，但是对于 static 成员它支持在外部进行定义，且不需要加上 static，sizeof 在计算的时候并不会计算 static 成员的大小。

• _count是私有，怎么访问 ❓

定义一个公有函数 GetCount 函数，返回 _count：调用函数
1、最后实例化对象后调用 GetCount 函数并减 1
2、直接匿名对象并减 1
3、将 GetCount 函数定义成静态成员函数并使用类域调用

💦 关于静态的特性

1️⃣ 静态成员变量为所有类对象所共享，不属于某个具体的实例。

2️⃣ 静态成员变量必须在类外定义，定义时不添加 static 关键字。

3️⃣ 类静态成员即可用类名::静态成员或者对象.静态成员来访问。

4️⃣ 静态成员函数没有隐藏的 this 指针，不能访问任何非静态成员。

5️⃣ 静态成员和类的普通成员一样，也有 public、protected、private3种访问级别，也可以具有返回值。

---

【面试题1】
static 的作用 C 语言 | C++ ❓

C 语言：

1、 static 修饰局部变量，改变了局部变量的生命周期　(本质上是改变了变量的存储类型)，局部变量由栈区转向静态区，生命周期同全局变量一样

2、 static 修饰全局变量，使得这个全局变量只能在自己所在的文件内部使用，而普通的全局变量却是整个工程都可以使用

❓ 为什么全局变量能在其它文件内部使用 ❔

因为全局变量具有外部链接属性；但是被 static 修饰后，就变成了内部链接属性，其它源文件不能链接到这个静态全局变量了

3、 static 修饰函数，使得函数只能在自己所在的文件内部使用，本质上 static 是将函数的外部链接属性变成了内部链接属性 (同 static 修饰全局变量)

C++：

1、修饰成员变量和成员函数，成员变量属于整个类，所有对象共享，成员函数没有 this 指针。

---

三、友元

友元分为：友元函数和友元类

友元提供了一种突破封装的方式，有时提供了便利。但是友元会增加耦合度，破坏了封装，所以友元不宜多用。

💦 友元函数

❓ 重载<< ❔

class Date
{friend ostream& operator<<(ostream& out, const Date& d);//友元，位置可任意，一般是开头friend istream& operator>>(istream& in, Date& d);//友元
public:Date(int year = 0, int month = 0, int day = 1): _year(year), _month(month), _day(day){}/*void operator<<(ostream& out){out << _year << "/" << _month << "/" << _day << endl;}*/
private:int _year;int _month;int _day;
};
ostream& operator<<(ostream& out, const Date& d)//支持连续输出
{out << d._year << "/" << d._month << "/" << d._day << endl;return out;
}
istream& operator>>(istream& in, Date& d)//支持连续输入
{in >> d._year >> d._month >> d._day;return in;
}
int main()
{Date d1, d2;cin >> d1 >> d2;//cout << d1 ? d1 << cout//cout << d1;/*d1.operator<<(cout);d1 << cout;*/cout << d1 << d2;return 0;
}

📝说明

cin | cout 怎么接收 ❓

在 C++ 里 cout 是一个 ostream 的对象；cin 是一个 istream 的对象。

cout << d1 | d1 << cout(d1.operator<<(cout)) ❓

**为啥不能 cout << d1 呢 ？**❓

运算符有几个操作数，重载函数就有几个参数。如果有两个操作数，左操作数是第一个参数，右操作数是第二个参数。

在 Date 类成员函数 operator<< 里对象是第一个参数，因为隐含的 this 指针已经默认占据了，那么 cout 就只能作第二个操作数了。可以倒也可以，但是用起来不符合流运算符原来的特性。

**怎么改成 cout << d1 呢 ？**❓

也就是把 cout 作为第一个参数，那么这里就不能用成员函数了，之前我们用成员函数是因为成员变量是私有的。

如何取舍：使用成员函数 | 使用全局函数。这里成员函数的可读性差影响较大，所以将之舍弃，使用全局函数。

支持 cout << d1 后怎么解决私有 ？

解决方案1：提供公有的成员函数 GetYear、GetMonth、GetDay

解决方案2：友元函数

这里我们就引出了友元，C++ 默认是不能在类外访问私有的，但是它提供了友元以帮助我们解决这种场景的问题。友元函数可以直接访问类的私有成员，它是定义在类外部的普通函数，不属于任何类，但需要在类的内部声明，声明时需要加 friend 关键字。

💨小结

1、友元函数可访问类的私有和保护成员，但不是类的成员函数。

2、友元函数不能用 const 修饰，因为 const 修饰的是 this 指针指向的对象。

3、友元函数可以在类定义的任何地方声明，不受类访问限定符限制。

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

5、友元函数的调用与普通函数的调用和原理相同。

🍳拓展

这里主要拓展代码错误的解决能力，先来看一段代码。

class A
{friend void f(const A& aa, const B& bb);
public:A(int a = 0): _a(0){}
private:int _a;
};
class B
{friend void f(const A& aa, const B& bb);
private:int _b = 0;A _aa;
};
void f(const A& aa, const B& bb)
{cout << aa._a << endl;	cout << bb._b << endl;
}
int main()
{A aa;B bb;f(aa, bb);return 0;
}

📝分析

相信到了这里绝大部分的人都能凭借着自己的经验去解决大部分的 bug了。但是对于上面代码出现的错误又百思不得其解。

注意面对这种情况的时候，有时候编译器报的错误是不准确的，这里有两条建议能帮助提升查找 bug 的能力。

1、有很多错误的时候，一定是看最上面的错误，因为下面的错误有可能是上面的错误间接导致的。

2、排除法，这里有一百行代码(程序崩了)，你注释掉了部分代码程序正常了，那么不用怀疑，错误就是注释处代码引发的。

经过分析，我们发现错误处是：在 B 类的友元里能找到 A、B；但是在 A 类的友元里就找不到 B 了。所以解决方法就是加前置声明 —— class B;

---

💦 友元类

class Date; //前置声明
class Time
{friend class Date;//声明日期类为时间类的友元类，则在日期类中就直接访问Time类中的私有成员变量
public:Time(int hour, int minute, int second): _hour(hour), _minute(minute), _second(second){}private:int _hour;int _minute;int _second;
};
class Date
{
public:Date(int year = 1900, int month = 1, int day = 1): _year(year), _month(month), _day(day)
{}
void SetTimeOfDate(int hour, int minute, int second)
{//直接访问时间类私有的成员变量_t._hour = hour;_t._minute = minute;_t.second = second;
}
private:int _year;int _month;int _day;Time _t;
};

📝分析

友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员。

1、友元关系是单向的，不具有交换性。比如上述 Time 类和 Date 类，在 Time 类中声明 Date 类为其友元类，那么可以在 Date 类中直接访问 Time 类的私有成员变量，但想在 Time 类中访问 Date 类中私有的成员变量则不行。

2、友元关系不能传递，如果 C 是 B 的友元， B 是 A 的友元，则不能说明 C 是 A 的友元。

四、内部类

概念：如果一个类定义在另一个类的内部，这个内部类就叫做内部类。注意此时这个内部类是一个独立的类，它不属于外部类，更不能通过外部类的对象去调用内部类。外部类对内部类没有任何优越的访问权限。

注意：内部类就是外部类的友元类。注意友元类的定义，内部类可以通过外部类的对象参数来访问外部类中的所有成员。但是外部不是内部的友元。

特性：

1、内部类可以定义在外部类的 public、protected、private 都是可以的。

2、注意内部类可以直接访问外部类中的 static、枚举成员、不需要外部类的对象/类名。

3、sizeof (外部类) = 外部类，和内部类没有任何关系。

class A
{
private:static int k;int h;
public:class B//B类天生就是A的友元{public:void foo(const A& a){cout << k << endl;//okcout << a.h << endl;//ok	}private:int _b;};
};
int A::k = 0;
int main()
{cout << sizeof(A) << endl;//4A::B b;//要用B去定义，必须得指定域b.foo(A());return 0;
}

📝说明

sizeof 在计算 A 类型对象大小的时候，不考虑 B 类。因为 B 作为 A 的内部类，跟普通类没有什么区别，只是定义在 A 的内部，它受到 A 的类域的限制和访问限定符的限制。

一般情况是一个类专门为另一个类服务是才会用到内部类。

---