C++----类与对象（下篇）

再谈构造函数

回顾函数体内赋值

在创建对象时，编译器通过调用构造函数，给对象中各个成员变量一个合适的初始值。

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

注意：虽然上述构造函数调用之后，对象中已经有了一个初始值，但是不能将其称为对对象中成员变量的初始化， 构造函数体中的语句只能将其称为赋初值，而不能称作初始化。因为初始化只能初始化一次，而构造函数体内可以多次赋值。

初始化列表

格式

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

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

注意

1. 每个成员变量在初始化列表中最多只能出现一次(因为初始化只能初始化一次)

2. 类中包含以下成员，必须放在初始化列表位置进行初始化： 引用成员变量 、const成员变量 、自定义类型成员(且该类没有默认构造函数时)

为什么呢？

首先，当类的对象实例化时，会调用构造函数，如果有对成员变量赋值的操作，就会对成员变量进行赋值。引用成员变量、const成员变量必须在定义的时候初始化，不能再进行赋值操作，因为引用必须初始化，且当一个引用一旦引用了一个实体，就不能通过赋值操作再引用实体；而const 成员变量的值一旦被设定就不能通过赋值操作改变。

class B{ 
public: //正确写法：//初始化列表：对象成员变量定义的位置，符合初始化只能初始化一次的要求。B(int a, int ref):_ref(ref),_n(10) {}//错误写法：B(int a, int ref) {//这里并不是对象成员变量定义的位置，是函数体内赋值，对成员变量赋值的地方。_ref=ref;_n=a;} private: //这里只是成员变量声明的地方，不是定义的地方。int& _ref; // 引用 const int _n; // const 
}; int main(){// 对象实例化B bb1(10, 1); B bb2(11, 2);return 0;
}

对于自定义类型成员变量_aobj，如果它有默认构造函数，那么可以不显式地在初始化列表中初始化它，编译器会自动调用默认构造函数。如果没有默认构造函数，则必须在初始化列表中显式调用其构造函数。

A 有默认构造函数：

class A {
public:A(int a = 0) : _a(a) {}private:int _a;
};class B {
public:// A 有默认构造函数，所以可以不显式初始化 _aobjB(int a, int ref) : _ref(ref), _n(10) {}private:A _aobj; // 有默认构造函数int& _ref; // 引用const int _n; // const
};

A 没有默认构造函数：

class A {
public:A(int a) : _a(a) {}private:int _a;
};class B {
public:// 在初始化列表中显式调用 A 的构造函数B(int a, int ref) : _aobj(a), _ref(ref), _n(10) {}private:A _aobj; // 无默认构造函数int& _ref; // 引用const int _n; // const
};

对于内置类型（如 int），如果初始化列表中没有显式初始化，则使用缺省值（如果有的话）或者未定义值（如果没有缺省值）。如果初始化列表中显式初始化了内置类型成员，则使用指定的值。

class B {
public:// 写法1：_x 未在初始化列表中显式初始化，使用缺省值 1B(int a, int ref) : _ref(ref), _n(10) {}// 写法2：_x 在初始化列表中显式初始化为 2B(int a, int ref, int x) : _ref(ref), _n(10), _x(2) {}private:int& _ref; // 引用const int _n; // constint _x = 1; // 缺省值为 1，但仅在未显式初始化时使用
};

3.尽量使用初始化列表初始化，因为不管你是否使用初始化列表，对于自定义类型成员变量，一定会先使用初始化列表初始化。

我们先来看一个代码：

typedef int DataType;
class Stack {
public:Stack(size_t capacity = 10) {_array = (DataType*)malloc(capacity * sizeof(DataType));if (nullptr == _array) {perror("malloc 申请空间失败");return; }_size = 0;_capacity = capacity;}// ... 其他成员函数private:DataType* _array;size_t _size;size_t _capacity;
};class MyQueue {
public:MyQueue() {} MyQueue(int capacity) {}private:Stack _pushst;Stack _popst;
};int main()
{MyQueue q1;//这里的q1._pushst和q1._popst成员变量的capacity都是10。return 0;
}

即使在MyQueue类中的构造函数里什么操作都没有，我们也没有写初始化列表，当MyQueue类实例化对象时调用到MyQueue构造函数了，也会调用到_pushst和_popst成员变量的构造函数，因为MyQueue类中所有的成员变量还是会走初始化列表。但是如果我们显示化地写处初始化成员列表，它就会走我们写的显示化的初始化成员列表，这样我们就可以根据自己的需求设置_pushst和_popst成员变量的容量大小了（_capacity）：

class MyQueue {
public:// 默认构造函数，不显式初始化_pushst和_popst，它们将使用Stack的默认构造函数（capacity为10）MyQueue() {}// 有参构造函数，使用初始化列表显式初始化_pushst和_popst的capacityMyQueue(int capacity) : _pushst(capacity), _popst(capacity) {}private:Stack _pushst; Stack _popst;  
};int main() {MyQueue q1; // 使用默认构造函数，q1._pushst和q1._popst的capacity都是10MyQueue q2(100); // 使用有参构造函数，q2._pushst和q2._popst的capacity都是100return 0;
}

4.用初始化列表动态分配空间

class Stack{
public:Stack(int capacity = 10): _a((int*)malloc(capacity * sizeof(int))),_top(0),_capacity(capacity){if (nullptr == _a){perror("malloc申请空间失败");exit(-1);}// 要求数组初始化一下memset(_a, 0, sizeof(int) * capacity);}
private:int* _a;int _top;int _capacity;
};

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

我们来看这样的代码：

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(); return 0;
} 

 最后它会输出什么呢？答案：1 随机值

因为它先声明的是_a2，所以初始化列表中也会先声明_a2。但此时_a1还没有被赋值（所以是随机值），所以_a2会被赋值为随机值。然后再初始化_a1，把a赋给_a1，所以_a1就是1了，所以最后会输出1 随机值。

所以建议声明的顺序和定义的顺序保持一致。

explicit关键字

我们来看这样的代码：

#include <iostream>
using namespace std;class A {
public:A(int a) : _a(a) {cout << "A(int a)" << endl;}A(const A& aa) : _a(aa._a) {cout << "A(const A& aa)" << endl;}private:int _a;
};int main() {A aa1(1);  // 直接调用构造函数 A(int a)A aa2 = 2; // 隐式类型转换：2 转换为 A 的临时对象，然后拷贝构造 aa2// 注意：以下代码会导致编译错误，因为不能从 int 直接转换为 A&// A& aa3 = 2; // error C2440: “初始化”: 无法从“int”转换为“A &”// 但是，可以转换为 const A&，因为临时对象具有常性const A& aa3 = 2; // 隐式类型转换：2 转换为 A 的临时对象，然后绑定到 const A& aa3return 0;
}

在这个例子中，A aa2 = 2; 发生了隐式类型转换，2 被用来构造一个 A 类型的临时对象，然后这个临时对象通过拷贝构造函数来初始化 aa2。然而，在同一个表达式里出现连续构造时，现代编译器通常基本都会有这样的优化。

如果我们不想要这样的隐式转换发生该怎么办呢？

在初始化列表前面加一个expilicit就可以了：

#include <iostream>
using namespace std;class A {
public:explicit A(int a) : _a(a) {cout << "A(int a)" << endl;}A(const A& aa) : _a(aa._a) {cout << "A(const A& aa)" << endl;}private:int _a;
};int main() {A aa1(1);  // 直接调用构造函数 A(int a)// 下面的代码会报错，因为 explicit 禁止了隐式类型转换// A aa2 = 2; // error C2440: “初始化”: 无法从“int”转换为“const A &”// 同样，即使绑定到 const A&，隐式类型转换也被禁止// const A& aa3 = 2; // error C2440: “初始化”: 无法从“int”转换为“const A &”// 正确的做法是显式调用构造函数A aa2(2);  // 直接调用构造函数 A(int a)const A& aa3 = A(2); // 显式创建临时对象并绑定到 const A&return 0;
}

static成员

概念

声明为 static 的类成员称为类的静态成员。用 static 修饰的成员变量称为静态成员变量；用 static 修饰的成员函数称为静态成员函数。

特性

1.静态成员也是类的成员，受public、protected、private 访问限定符的限制

2.静态成员为所有类对象所共享，不属于某个具体的对象，存放在静态区。

class A{
public:A(){++_scount;}A(const A& t) {++_scount;}~A(){ --_scount;}private:// 成员变量 -- 属于每个一个类对象，存储对象里面int _a1 = 1;int _a2 = 2;// 静态成员变量 -- 属于类，属于类的每个对象共享，存储在静态区，生命周期是全局的static int _scount;
};

3. 静态成员变量必须在类外定义，定义时不添加static关键字，类中只是声明。静态成员变量不能通过缺省值初始化，因为静态成员没有初始化列表

class A{
public:A(){++_scount;}A(const A& t) {++_scount;}~A(){ --_scount;}private:// 成员变量 -- 属于每个一个类对象，存储对象里面int _a1 = 1;int _a2 = 2;// 静态成员变量 -- 属于类，属于类的每个对象共享，存储在静态区，生命周期是全局的static int _scount;// 静态成员变量不能通过缺省值初始化，因为静态成员没有初始化列表// static int _scount = 0; //错误做法
};

4. 类静态成员即可用 类名::静态成员 或者 对象.静态成员 来访问 ,但是要注意一些问题：

虽然可以通过对象访问静态成员，但一般不推荐这样做，因为静态成员不属于任何对象。此外，如果静态成员是私有的，则不能直接从类或对象外部访问它，需要通过公有成员函数来访问。

代码例子（错误示范）：

int main() {// _scount 是私有的// 下面的代码会报错，不能突破私有权限访问静态成员变量cout << A::_scount << endl;A a;cout << a::_scount << endl;return 0;
}

正确访问方式：

class A {
public:static int GetCount() {return _scount;}private:static int _scount;
};int A::_scount = 0;int main() {A a;cout << "Count: " << A::GetCount() << endl; // 正确访问cout << "Count: " << a.GetCount() << endl;  // 也可以通过对象访问，但不推荐return 0;
}

5. 静态成员函数没有隐藏的this指针，不能访问任何非静态成员 ，但是非静态成员函数可以调用类的静态成员函数。

class A {
public:static int GetCount() {// 不能访问非静态成员// _a1++; // 错误return _scount;}void NonStaticFunc() {// 非静态成员函数可以调用静态成员函数GetCount();}private:int _a1 = 1;static int _scount;
};int A::_scount = 0;int main() {A a;a.NonStaticFunc(); // 调用非静态成员函数，内部调用静态成员函数return 0;
}

友元

友元函数

前面我们讲过流插入和流提取运算符的重载，就用到了友元C++----类与对象（中篇）-CSDN博客。

友元类

• 友元关系是单向的，不具有交换性：比如在Time类中声明Date类为其友元类，那么可以在Date类中直接访问Time类的私有成员变量，但想在Time类中访问Date类中私有的成员变量则不行。
• 友元关系不能传递：如果B是A的友元，C是B的友元，则不能说明C时A的友元。
• 友元关系不能继承，在继承位置再给大家详细介绍。

class Time{friend class Date; // 声明日期类为时间类的友元类，则在日期类中就直接访问Time类中的私有成
员变量
public:Time(int hour = 0, int minute = 0, int second = 0): _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. 内部类可以定义在外部类的public、protected、private。

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

class A{
private:static int k;int h;
public:class B // B天生就是A的友元{public:void foo(const A& a){cout << k << endl;//OK：直接访问外部类的静态成员变量cout << a.h << endl;//OK}};
};int A::k = 1;int main()
{A::B b;//实例化内部类B对象的写法b.foo(A());return 0;
}

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

class A{
private:static int k;int h;
public:class B // B天生就是A的友元{public:void foo(const A& a){cout << k << endl;//OK：直接访问外部类的静态成员变量cout << a.h << endl;//OK}};
};int A::k = 1;int main()
{cout << sizeof(A) <<endl;return 0;
}

最终结果会输出4，我们来分析一下：

首先，需要明确的是，sizeof(A)所计算的是类A的实例在内存中所占的大小，而非类A本身作为一个类型的大小。在类A中，static int k 是一个静态成员变量。静态成员变量是属于类的，而不是类的实例的。因此，它不会占用类实例的内存空间。所有类的实例共享同一个静态成员变量的值。int h; 是一个非静态成员变量。它属于类的每个实例，并且会占用内存空间。B是A的一个嵌套类，但是它没有存在外部类A中，也没有在外部类A中创建内部类的对象，所以也不会增加A的实例的大小。唯一占用空间的是h，它是一个int类型，占用4个字节。

匿名对象

概念

匿名对象是在表达式中临时创建的对象，没有名字，通常用于简化代码或直接在需要对象的地方进行一次性使用。

class A{
public:A(int a = 0):_a(a){cout << "A(int a)" << endl;}~A(){cout << "~A()" << endl;}
private:int _a;
};int main(){A aa(1);  // 有名对象A(2);     // 匿名对象return 0;
}

特征

1.调用成员函数的格式

#include<iostream>
using namespace std;class Solution {
public:int Sum_Solution(int n) {cout << "Sum_Solution" << endl;//...return n;}
};int main(){Solution sl;sl.Sum_Solution(10);//有名对象调用函数的写法Solution().Sum_Solution(20);//匿名对象调用函数的写法return 0;
}

2.即用即销毁

class A{
public:A(int a = 0):_a(a){cout << "A(int a)" << endl;}~A(){cout << "~A()" << endl;}
private:int _a;
};int main(){A aa(1);  // 有名对象--有名对象的生命周期在当前函数局部域A(2);     // 匿名对象--匿名对象的生命周期在所在当前行的表达式return 0;
}

3.匿名对象具有常性

#include<iostream>
using namespace std;class A{
public:A(int a = 0):_a(a){cout << "A(int a)" << endl;}~A(){cout << "~A()" << endl;}
private:int _a;
};int main(){A aa(1);  // 有名对象 -- 生命周期在当前函数局部域A(2);     // 匿名对象 -- 生命周期在所在当前行的表达式//A& ra = A(1);  // 错误写法const A& ra = A(1); //正确写法：匿名对象具有常性return 0;
}

4.const引用可以延长匿名对象的生命周期

对于上一段代码，也许你会觉得，由于匿名对象的生命周期在当前行的表达式，所以ra在下一行就有变成类似于“野引用”的风险。但是const引用可以延长匿名对象的生命周期，生命周期延长至在当前函数局部域。

#include<iostream>
using namespace std;class A{
public:A(int a = 0):_a(a){cout << "A(int a)" << endl;}~A(){cout << "~A()" << endl;}
private:int _a;
};int main(){A aa(1);  // 有名对象 -- 生命周期在当前函数局部域A(2);     // 匿名对象 -- 生命周期在所在当前行的表达式const A& ra = A(1); // const引用延长匿名对象的生命周期，生命周期在当前函数局部域A(10);return 0;
}

应用：C++ 编译器优化

在C++中，编译器会对临时对象的构造和拷贝进行优化，以减少不必要的开销。

以该代码为例：

#include<iostream>
using namespace std;class A
{
public:A(int a = 0):_a(a){cout << "A(int a)" << endl;}A(const A& aa):_a(aa._a){cout << "A(const A& aa)" << endl;}A& operator=(const A& aa){cout << "A& operator=(const A& aa)" << endl;if (this != &aa){_a = aa._a;}return *this;}~A(){cout << "~A()" << endl;}
private:int _a;
};void Func1(A aa)
{}A Func2() {A aa; // 构造一个A对象return aa; // 返回值优化：一般会调用拷贝构造
}

1. 拷贝构造+拷贝构造——>一次构造（返回值优化）

当函数返回一个对象时，编译器可能会优化掉返回过程中的拷贝构造，直接构造返回的对象在目标位置。

int main() {cout << "在同一行同一个表达式时：" << endl;A ra1 = Func2(); // 拷贝构造+拷贝构造 ->优化为拷贝构造// 输出可能只显示一次构造和一次析构cout << "不在同一行同一个表达式时：" << endl;A a1;a1 = Func2();return 0;
}

输出：

2. 构造+拷贝构造——>优化为一次构造

在同一行或同一个表达式中，如果发生构造和拷贝构造，编译器可能会优化为只进行一次构造。

int main() {cout << "不会优化，因为aa1是一个已存在的对象，需要被拷贝到Func1的参数中:" << endl;A aa1;Func1(aa1);  // 但是：cout << "构造+拷贝构造 -> 优化为构造（临时对象直接构造在Func1的参数位置）:" << endl;Func1(A(1));  cout << "同上，构造一个A对象时，可能会直接构造在Func1的参数位置:" << endl;Func1(1);    cout << "构造+拷贝构造 -> 优化为构造（直接构造aa2）:" << endl;A aa2 = 1;  return 0;
}

输出：