【C++】详解初始化列表，隐式类型转化，类静态成员，友元

阅读本书更多章节>>>>

前言

初始化列表是对构造函数内容的补充，小编会详细的讲解初始化列表的概念，特性，注意点。这是本篇内容的重头戏，小编会先提一个问题来抛砖引玉。

隐式类型转换顾名思义，首先它不需要主动转换，然后就是不同类型之间的转换。

如果把在类成员前面加上static关键字会发生什么，小编也会详细讲解。

对于友元，小编会解析它的概念和用法

小编希望这篇文章能带给大家启发，相互探讨其中的奥秘。本篇内容如有不足之处，还请指正，小编会虚心接受并及时改进质量。

---

初始化列表

问题引导

因为初始化列表是构造函数的一部分，小编专门写了一篇构造函数供大家参考。

【C++】详解构造函数：http://t.csdnimg.cn/KuDZd

小编先抛给大家一个问题，有如下代码

class Time{public:Time(int huor, int miunte, int second)  //Time类的带参构造函数{_huor = huor;_minute = miunte;_second = second;cout << "Time带参数构造" << endl;}private:int _huor;  //时int _minute;  //分int _second;  //秒};class Date{public:private:int _year; //年int _month; //月int _day;  //日Time _t;  //时间类的对象};

上述代码中， 定义了一个时间类Time和日期类Date。 时间类中定义了带参的构造函数 ，日期类并没有显式定义构造函数。时间类的对象_t是日期类的成员变量。那么，上述代码中有什么错误吗？

会在实例化日期类对象的时候报错。

这个报错有点抽象。造成这样报错的原因是：Date类在实例化对象时，系统会生成Date类默认的构造函数，该函数对内置类型不做处理，对自定义类型（_t）会调用该类型的默认构造函数，但我们并没有显式定义Time类的默认构造函数，而且Time类中有带参数的构造函数，所以系统也不会自动生成Time类的默认构造函数。

画图帮大家理解一下

上述问题的核心是：要么Time类没有显式的定义默认构造函数，要么不能通过Date类给Time类中的带参构造函数传参，导致自定义成员变量_t不能完成初始化。

如果在Time类中显式定义默认构造函数，这个问题自然就解决了。那我们能不能通过传参来解决呢？

至此，就要请出本篇的第一个重点：初始化列表

概念引导

在实例化对象对象时，编译器会调用构造函数给给成员变量赋一个初始值。此时，编译器的行为叫不叫初始化呢?答案是不叫。此时编译器的行为叫赋初值，就是给该成员变量一个值。因为初始化只能初始化一次，而构造函数体内可以多次赋值。

写法

写法：冒号开头，逗号分隔，中间是成员变量，成员变量后跟括号，括号里给初始值或表达式

位置：构造函数的函数名和函数体之间

图像示例

代码示例

Date():_year(2024),_month(4),_day(22),_t(7,3,0){}

问题解决

既然我们能写出参数列表，就能在实例化Date类的时候给Time类的带参构造函数传参吗？

调试可知，初始化列表确实解决了传参问题

写法的细节

上述示例中我们是在无参构造函数名和函数体之间写的初始化列表，能不能再有参构造上写呢？答案是可以的如下代码

Date(int year, int month, int day, Time t) :_year(year),_month(month),_day(day),_t(t) {}

那可不可以函数体和初始化函数混着来呢？答案是可以的，为了方便，甚至可以不要Time类型的形参如下代码

Date(int year, int month, int day) :_day(day) ,_t(7,3,0){_year = year;_month = month;}

但不要把自定义类型_t写进函数体，因为我们是想在Date类中就能把参数传给Time类中的带参构造函数，所以_t必须写进初始化列表。

初始化列表传参是很自由的，可以传值，传表达式，也可以传个函数。如下代码

int fuc(){return 2 + 3;}Date(int year, int month, int day):_day(1 + 2 + 22 - 10), _year(fuc()) ,_t(7,3,0) {_month = month;}

注意点

变量的初始化一定在初始化列表

如果显式的写了初始化列表，编译器会走写好的初始化列表。如果没有写，编译器会走默认生成的初始化列表，该初始化列表对内置类型不做处理，对自定义类型会调用该类型的默认构造函数

下面三个成员必须放在初始化列表

1.没有默认构造的自定义成员变量

2.引用成员变量

3.const成员变量

第一点在上面的内容中说明了。小编解析一下第二点和第三点，在创建引用变量的时候必须指定引用的对象，并且该指定不能被改变。const成员变量具有常性，不可被改变。观察一下就会发现这两类变量有且只有唯一一次被赋值的机会，就是在初始化的时候。而成员变量是在初始化列表初始化的，所以上述三类变量放在初始化列表。

因为每个成员变量只能初始化一次，所以成员变量在初始化列表只能出现一次。如果在初始化列表出现两次就会强制报错

成员变量在初始化列表中初始化的顺序是其在类中声明的顺序，而不是在初始化列表中的前后次序。小编为大家找来了一道面试题，看下大家能作对吗，代码如下

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，大家做对了吗

到此为止，恭喜你把本篇的硬骨头啃下了，下面小编会为大家讲解一下类和对象的其他语法

---

隐式类型转换

概念：不同的内置类型相互转换或者把内置类型转化为类类型

单参数隐式类型转换

如下代码

class Test  //定义一个类{public:Test(int a) //类的构造函数:_a(1) //初始化列表{}private:int _a;  //私有数据_a};int main(){Test t = 3;  //隐式类型转换return 0;}

3是整型，t是类类型，很显然，把3转换成了类类型。这是怎么转换的呢？

其实，是编译器调用了test类的构造函数从而实例化了一个对象，这个对象叫做临时对象_a的值是3，临时对象具有常性。然后编译器会再调用拷贝构造，把临时对象拷贝给对象t。

画个图帮大家理解一下

如果在一个表达式中有连续的构造和拷贝构造，编译器会直接把拷贝构造优化掉。直接把整形3构造成t对象。因为编译器通过更小的消耗实现了相同的效果。但我们在语言层面不能把拷贝构造去掉。 小编专门写了一篇拷贝构造供大家参考  http://t.csdnimg.cn/gQ9CW

多参数隐式类型转换

如下代码

class Test{public:Test(int a,int b,int c)  :_a(a),_b(b),_c(c){}private:int _a;int _b;int _c;};int main(){Test t = { 2, 4, 6 };return 0;}

在语法上，需要把多个参数用大括号括起来

Test t = { 2, 4, 6 };

explicit关键字

在构造函数的函数名前加上 explicit关键字，可以禁止隐式类型转换

如下代码

explicit Test(int a,int b,int c):_a(a),_b(b),_c(c){}

此时就不能实现隐式类型转换了

---

static成员

概念

被static修饰的变量成为静态成员变量，被static修饰的函数成为静态成员函数。

特性

静态成员为所有类对象所共享，该成员存放在静态区

静态成员变量要在类外面定义。

对于变量而言，“定义”一词的界定应为变量是否开空间。在初始化就是在为变量开空间。静态成员是具有全局性的，不可能每次都实例化对象时都初始化该成员变量

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

如果静态成员时公有，可通过类名::静态成员  或  对象.静态成员访问。

静态成员函数没有隐藏的this指针，所以不能访问非静态成员。

---

友元

友元函数

一个普通的A函数如果在B类中声明并且在前面加上friend关键字，那么A函数就是B类的友元函数，A函数就可以访问B类的私有成员变量。如下代码，大家感受一下

class B{friend void A(); //友元函数Apublic:private:int _a; //私有数据_a};void A(){B b;cout << b._a<< endl;  //直接访问_a}

友元函数的注意点

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

友元函数不能用const修饰

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

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

友元函数的调用与普通函数的调用原理相同

友元类

友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员 友元关系是单向的 友元关系不能传递 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;  //时间类对象};

内部类

如果把A类定义在B类内部，那么这个A类就是内部类。

但A类和B类是平行关系（如果计算外部类的大小，是算不到内部类的），唯一的联系就是，A类是B类的友元类。

内部类不受访问限定符限制，可以定义在外部类的任何位置

---

好啦，本篇的内容到此结束啦

阅读本书更多章节>>>>

本文链接：https://www.kjpai.cn/gushi/2024-04-29/163407.html，文章来源：网络cs，作者：利杜鹃，版权归作者所有，如需转载请注明来源和作者，否则将追究法律责任！