初始化列表、匿名对象、static成员、类的隐式类型转换和explicit关键字、内部类
本章思维导图:
注:本章思维导图对应的xmind
文件和.png
文件都已同步导入至资源
1. 初始化列表
1.1 再谈构造函数
众所周知,每个变量只能被初始化一次,我们之前一直认为成员变量的初始化是在构造函数的函数体中,但是,成员变量是可以在构造函数的函数体出现多次的:
class Date { public: Date(int year = 1, int month = 1, int day = 1) { _year = year; _month = month; _day = day; //出现多次,且可以编译通过 _year = 100; _month = 200; } private: int _year; int _month; int _day; };
因此,我们只能认为在构造函数函数体内执行的是赋值操作,而不是初始化
这就说明,构造函数的函数体并不是类的成员变量真正初始化的地方,那么成员变量到底是在哪里初始化的呢?
1.2 初始化列表
初始化列表是成员变量真正初始化的地方
1.2.1 初始化列表的语法
初始化列表以分号
:
开始,以逗号,
分割,每个成员变量后面带上放在括号()
里的初始值或者表达式
例如,对于上面的构造函数:
Date(int year = 1, int month = 1, int day = 1) //初始化列表 : _year(year) , _month(month) , _day(day) { }
1.2.2 初始化列表的意义
初始化列表解决了三类不能在构造函数的函数体内初始化的问题:
&
修饰的引用成员变量——引用成员在定义时就必须初始化const
修饰的const
成员变量——const变量在定义时就必须初始化- 没有默认构造的自定义类型——在函数体内不能初始化自定义类型
也就是说,上面所说三类成员变量必须在初始列表里面进行初始化。
例如;
class Stack { public: //这不是默认构造,因为要传参数 Stack(int capacity) { } private: int* _a; int _capacity; int _top; }; class Date { public: Date(int year = 1, int month = 1, int day = 1) : num1(2) , num2(_year) , st(3) { _year = year; _month = month; _day = day; } private: int _year; int _month; int _day; const int num1; int& num2; Stack st; };
1.3 注意事项
- 因为初始化列表是成员变量初始化的地方,而每个变量又只能初始化一次,因此成员变量只能在初始化列表出现一次
- 因为初始化列表是真正初始化成员变量的地方,因此无论有没有显示的写出初始化列表,成员变量都会经过初始化列表的初始化。
- 如果没有显示的写出初始化列表,那么:
- 对于内置类型,那就赋予其初始值
- 对于自定义类型,就调用它的默认构造
- 能使用初始化列表就使用初始化列表。但也不是说初始化列表就能完全替代函数体。因为有时候函数体需要进行检查等操作。
- 初始化列表的初始化顺序是成员变量声明的顺序,而不是在初始化列表里出现的顺序。
class A { public: A() : a1(1) , a2(a1) { } void Print() { cout << a1 << endl << a2 << endl; } private: int a2; int a1; }; int main() { A a; a.Print(); return 0; } /*output: 1 -858993460 */ //a2声明在a1之前,因此,在初始化时,先执行a2(a1),此时a1为随机值 //因此建议成员变量的初始化顺序和声明顺序一致
2. 匿名对象
class Date { public: Date(int year = 1, int month = 1, int day = 1) : _year(year) , _month(month) , _day(day) { myCount++; } void Print() { cout << "Date" << endl; } private: int _year; int _month; int _day; };
如果我们想不实例化对象,但想调用Date
类里的Print()
函数来知道这是个什么类,该如何做到呢?
这里就可以用到我们的匿名对象来解决:
int main() { Date().Print(); //Date()创建出一个匿名对象,再用这个匿名对象来调用成员函数Print() return 0; }
创建匿名对象的方式:
className()
匿名对象的特点:
- 匿名对象是一种临时对象,它没有分配给任何命名变量,而是在需要时被创建并使用
- 其生命周期仅存在于当前行,执行完后立即销毁
- 匿名对象一般是常量对象,不可被修改
3. static成员
如果我们想记录一个类究竟被构造了多少次
我们不难写出这样的代码:
//定义一个全局变量来记录类A构造的次数 int myCount = 0; class A { public: //构造函数 A() { myCount++; } //拷贝构造 A(A& a) { myCount++; } }; int main() { A a[10]; cout << myCount << endl; return 0; }
但是这就出现了一个问题:我们可以在全局随意修改变量
myCount
的值:
int main() { A a[10]; myCount++; cout << myCount << endl; return 0; }
这样也就不能保证类被构造次数的正确性了。
3.1 static成员变量
为了解决这个问题,我们可以在类里面声明一个static
成员,并用这个成员来记录类被构造的次数:
class A { public: //构造函数 A() { myCount++; } //拷贝构造 A(A& a) { myCount++; } private: static int myCount; }; int A::myCount = 0;
这个由static
修饰的静态成员变量有如下特点:
- 这实际上也是一个全局变量,只是受类域和访问限定符所限制
- 静态成员变量只能在类里面声明在类外面定义。
- 静态成员变量在声明时不能和非静态成员变量一样给缺省值,因为这个缺省值是给初始化列表里用的,而静态成员变量不用初始化列表初始化。
- 由
static
修饰的静态成员变量是这个类所属的,而不是由这个类实例化的某个对象所独有的
3.2 static成员函数
知道如何利用
static
成员变量之后,针对最开始的问题,我们不难写出下面的代码:
class A { public: //构造函数 A() { myCount++; } //拷贝构造 A(A& a) { myCount++; } //因为myCount被private修饰,在类外面无法访问 //因此要用成员函数访问myCount int GetCount() { return myCount; } private: static int myCount; }; int A::myCount = 0; int main() { A a[10]; //为了调用GetCount成员函数,必须要实例化一个对象,而这个对象是没有意义的,因此最终结果要减一 cout << A().GetCount() - 1 << endl; return 0; }
但是又有一个问题出现了:
我们只是想知道
A
类到底被调用了多少次,但是要知道这个结果又必须新实例化一个对象,有没有什么方法不实例化对象就可以直接得到myCount
的值呢?
为了解决上述问题,就需要用到static
成员函数
class A { public: //构造函数 A() { myCount++; } //拷贝构造 A(A& a) { myCount++; } //static静态成员函数 static int GetCount() { return myCount; } private: static int myCount; }; int A::myCount = 0; int main() { A a[10]; cout << A::GetCount() << endl; return 0; }
由static
修饰的静态成员函数有如下特点:
- 和静态成员变量一样,静态成员函数实际上也是一个全局函数,只是受类域和访问限定符限制
- 静态成员函数在类里面声明,但既可以在类外面定义也可以在类里面定义
- 和非静态成员函数不同,静态成员函数没有
this
指针,因此静态成员函数无法访问非静态成员变量和非静态成员函数,但也因如此,它可以直接通过类名和域作用限定符::
调用。
4. 类的隐式类型转换和explicit关键字
4.1 类的隐式类型转换
以前我们一般是这么实例化一个对象的:
class Date { public: private: }; int main() { Date d1; //利用构造函数实例化对象 Date d2(d1); //利用拷贝构造实例化对象 return 0; }
现在又有一个新的实例化对象的方法——类的隐式类型转换
class A { public: A(int a = 1) : _a(a) { } private: int _a; }; int main() { A A1 = 10; return 0; }
可以看出,整形10
确实被转换为了A
类型。
根据当隐式类型转换发生时会产生临时变量的知识点
,我们可以推导出A A1 = 10
这行代码的具体实现逻辑:
应该清楚,要支持这种隐式类型转换,该类的构造函数应该支持只传一个内置类型就可以实现构造
例如对于下面几种情况,就不支持内置类型隐式转换为类类型:
//Error_1 class A { public: A() : _a(a) { } private: int _a; }; int main() { A A1 = 10; return 0; } /* 报错: error C2065: “a”: 未声明的标识符 error C2440: “初始化”: 无法从“int”转换为“A” message : 无构造函数可以接受源类型,或构造函数重载决策不明确 */ //Error_2 class A { public: A(int a, int b) : _a(a) { } private: int _a; int _b; }; int main() { A A1 = 10; return 0; } /* 报错: error C2440: “初始化”: 无法从“int”转换为“A” message : 无构造函数可以接受源类型,或构造函数重载决策不明确 */
类似的,对于有多个形参的构造函数,我们也可以传入多个内置类型进行构造:
class Date { public: Date(int year = 1, int month = 1, int day = 1) : _year(year) , _month(month) , _day(day) { } private: int _year; int _month; int _day; }; int main() { Date d3 = {2023, 11, 7}; //传入三个内置类型进行构造 return 0; }
4.1 explicit关键字
有些时候,如果我们不想让上面所说的隐式类型转换发生,我们可以在构造函数的声明前加上explicit
关键字:
explicit Date(int year = 1, int month = 1, int day = 1) : _year(year) , _month(month) , _day(day) { }
加上explicit
关键字后,如果继续进行隐式类型转换,就会报错:
error C3445: "Date" 的复制列表初始化不能使用显式构造函数
5. 内部类
C++支持在类的内部继续创建类,例如:
class A { public: class B { }; private: int _a; int _b; };
内部类有如下的特点:
- 内部类是一个独立的类,它不属于外部类,不能通过外部类的对象来访问内部类的成员
- 内部类天生就是外部类的友元类,可以直接访问外部类的成员变量和成员函数
class A { public: class B { void Print(A& a) { a._a = 1; } public: int _b; }; private: int _a; };
sizeof(外部类)
的结果和内部类无关
class A { public: class B { public: int _b; }; private: int _a; }; int main() { cout << sizeof(A) << endl; return 0; } //output:4
- C++类和对象的知识到这里就学习完毕了,之后博主会发布C++类和对象的总结篇
- 下一篇,博主将介绍C++的内存管理,感兴趣的小伙伴可以来看看哦~