0
0

【C++练级之路】【Lv.4】类和对象（下）（初始化列表，友元，static成员，编译器的优化）

目录

欢迎各位小伙伴关注我的专栏，和我一起系统学习C++，共同探讨和进步哦！

学习专栏：

《进击的C++》

一、再谈构造函数

1.1 构造函数体赋值

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

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

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

1.2 初始化列表

那么，成员变量到底是在什么地方初始化的呢？其实，在构造函数的初始化列表里。

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

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

特性：

  1. 每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)
  2. 类中包含以下成员，必须放在初始化列表位置进行初始化： - 引用成员变量- const成员变量- 自定义类型成员(且该类没有默认构造函数时)
classTime{public:Time(int hour):_hour(hour){}private:int _hour;};classDate{public:Date(int year,int month,int day):_year(year),_month(month),_day(day),_t(10){}private:int _year;constint _month;//constint& _day;//引用
    Time _t;//没有默认构造函数};
  1. 无论是否显式使用初始化列表，成员变量都在初始化列表定义。所以，尽量使用初始化列表初始化。
  2. 成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关。

请思考下面代码的运行结果：

classA{public:A(int a):_a1(a),_a2(_a1){}voidPrint(){
        cout<<_a1<<" "<<_a2<<endl;}private:int _a2;int _a1;};intmain(){
    A aa(1);
    aa.Print();}
A. 输出11 
B.程序崩溃
C.编译不通过
D.输出1  随机值

1.3 explicit关键字

先看看以下两种初始化的方式：

classTime{public:Time(int hour):_hour(hour){}private:int _hour;};intmain(){
    Time t1(4);
    Time t2 =4;return0;}

第一种方式毫无疑问是构造函数，而第二种方式是构造函数+拷贝构造。先构造出t2对象，再将4（int）隐式类型转换成（Time），最后拷贝给t2。但是，在较新的编译器下，会将该过程直接优化成带参构造。

C++98中，只允许对于单个参数或者除第一个参数无默认值其余均有默认值的构造函数隐式类型转换。

C++11中，增加了可对多参构造函数隐式类型转换，代码如下：

classTime{public:Time(int hour,int minute):_hour(hour),_minute(minute){}private:int _hour;int _minute;};intmain(){
    Time t1(4,5);
    Time t2 ={4,5};return0;}

而用explicit修饰构造函数，将会禁止构造函数的隐式转换。

classTime{public:explicitTime(int hour):_hour(hour){}explicitTime(int hour,int minute):_hour(hour),_minute(minute){}private:int _hour;int _minute;};intmain(){
    Time t1(4);
    Time t2 =4;//err
    Time t3(4,5);
    Time t4 ={4,5};//errreturn0;}

二、static成员

2.1 概念

用static修饰的成员变量，称之为静态成员变量；用static修饰的成员函数，称之为静态成员函数

2.2 特性

  1. 静态成员属于整个类，存放在静态区，而不属于某一个具体的对象
  2. 静态成员变量必须在类外定义，定义时不添加static关键字，类中只是声明
  3. 静态成员函数没有隐藏的this指针，不能访问任何非静态成员

面试题：实现一个类，计算程序中创建出了多少个类对象。

方法一：定义全局变量

因为std标准库中，有一个count的函数，所以防止命名冲突，局部展开。

using std::cout;using std::endl;int count =0;//全局变量classA{public:A(int a =4):_a(a){++count;}A(const A& a):_a(a._a){++count;}private:int _a;};intmain(){
    A a1;
    A a2 =5;
    A a3(3);

    cout << count << endl;return0;}

但是，这种方法也有很大缺陷，如果我不小心在外部直接对count进行修改，那结果就不对了。

intmain(){
    A a1;
    A a2 =5;
    A a3(3);++count;++count;
    
    cout << count << endl;return0;}

方法二：定义成员变量

但是，如果定义为成员变量，就属于某个具体的类了。所以，我们加上static关键字，让其属于整个类。

因为静态成员变量属于整个类，所以不在初始化列表中定义，而是在类外定义。

classA{public:A(int a =4):_a(a){++count;}A(const A& a):_a(a._a){++count;}staticintGetCount()//静态成员函数{return count;}private:int _a;staticint count;//静态成员声明};int A::count =0;//静态成员定义intmain(){
    A a1;
    A a2 =5;
    A a3(3);

    cout <<A::GetCount()<< endl;return0;}
  • 因为count变成private类型的成员变量，所以外界无法直接访问，就要通过成员函数来获取count。
  • 但是，调用非静态成员函数需要一个对象，所以为了简便，我们可以调用静态成员函数，这样就可以通过类域直接访问。

【问题】

  1. 静态成员函数可以调用非静态成员函数吗？
  2. 非静态成员函数可以调用类的静态成员函数吗？

三、友元

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

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

3.1 引入

当我们要重载流插入操作符<<时，如果定义为成员函数时，不符合常规写法逻辑：

classDate{public:Date(int year =2000,int month =1,int day =1):_year(year),_month(month),_day(day){}
    ostream&operator<<(ostream& out){
        out << _year <<"/"<< _month <<"/"<<_day<< endl;return out;}
    istream&operator>>(istream& in){
        in >> _year >> _month >> _day;return in;}private:int _year;int _month;int _day;};intmain(){
    Date d;
    d >> cin;//不符合常规写法逻辑
    d << cout;return0;}

这是因为cout的输出流对象和隐含的this指针在抢占第一个参数的位置。this指针默认是第一个参数也就是左操作数了。但是实际使用中cout需要是第一个形参对象，才能正常使用。

所以，我们只能将其重载为全局函数。但是，全局函数又没办法访问private成员，所以就用友元来解决。

3.2 友元函数

3.2.1 概念

友元函数可以直接访问类的私有成员，它是定义在类外部的普通函数，不属于任何类，但需要在类的内部声明，声明时需要加friend关键字。

classDate{friend ostream&operator<<(ostream& out,const Date& d);friend istream&operator>>(istream& in, Date& d);public:Date(int year =2000,int month =1,int day =1):_year(year),_month(month),_day(day){}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;}intmain(){
    Date d;
    cin >> d;
    cout << d;return0;}

3.2.2 特性

  • 友元函数可访问类的私有和保护成员，但不是类的成员函数
  • 友元函数不能用const修饰
  • 友元函数可以在类定义的任何地方声明，不受类访问限定符限制
  • 一个函数可以是多个类的友元函数

3.3 友元类

3.3.1 概念

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

3.3.2 特性

  • 友元关系是单向的，不具有交换性。 如果A是B的友元，不能说明B是A的友元。
  • 友元关系不能传递 如果C是B的友元， B是A的友元，则不能说明C时A的友元。
  • 友元关系不能继承，在继承位置再给大家详细介绍。
classTime{friendclassDate;//友元类public:Time(int hour =0,int minute =0,int second =0):_hour(hour),_minute(minute),_second(second){}voidPrint(){}private:int _hour;int _minute;int _second;};classDate{public:Date(int year =1900,int month =1,int day =1):_year(year),_month(month),_day(day){}voidSetTimeOfDate(int hour,int minute,int second){// 直接访问时间类私有的成员变量
        _t._hour = hour;
        _t._minute = minute;
        _t._second = second;}private:int _year;int _month;int _day;
    Time _t;};

简单理解：友元类可以访问定义友元的类，而定义友元的类不能访问友元类。

四、内部类

4.1 概念

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

注意：内部类就是外部类的友元类

4.2 特性

  1. 内部类可以定义在外部类的public、protected、private都是可以的。
  2. 注意内部类可以直接访问外部类中的static成员，不需要外部类的对象/类名。
  3. sizeof(外部类)=外部类，和内部类没有任何关系。
classA{private:staticint k;int h;public:classB// B天生就是A的友元{public:voidfoo(const A& a){
            cout << k << endl;//OK
            cout << a.h << endl;//OK}};};int A::k =1;intmain(){
    A::B b;
    b.foo(A());//传参A的匿名对象return0;}

注意：其他类不能访问内部类，只有对应的外部类才能访问内部类。

五、匿名对象

对象可以匿名，就像结构体匿名一样。

写法：类名（）

通常情况下，我们只想使用一次对象，就会使用匿名对象。

classSolution{public:intSum_Solution(int n){//...return n;}};intmain(){// 匿名对象在这样场景下就很好用，当然还有一些其他使用场景，这个我们以后遇到了再说
    cout <<Solution().Sum_Solution(10)<< endl;return0;}

六、编译器的优化

先写一个测试的类A

classA{public:A(int a =1):_a(a){
        cout <<"A(int)"<< endl;}A(const A& a):_a(a._a){
        cout <<"A(const A&)"<< endl;}
    A&operator=(const A& a){
        cout <<"A& operator=(const A&)"<< endl;if(this!=&a){
            _a = a._a;}return*this;}~A(){
        cout <<"~A()"<< endl;}private:int _a;};

6.1 传参优化

6.1.1 传值传参

优化一般只在同一表达式进行，不能跨表达式优化。

voidf1(A a){}intmain(){
    A a1 =1;//构造+拷贝构造——》优化为构造f1(a1);//无优化，只能在同一表达式进行优化f1(2);//构造+拷贝构造——》优化为构造f1(A(3));//构造+拷贝构造——》优化为构造return0;}

6.1.2 传引用传参

由于传引用本身就是最简，所以不需要优化。

voidf2(const A& a){}intmain(){
    A a1 =1;//构造+拷贝构造——》优化为构造f2(a1);//无优化f2(2);//无优化f2(A(3));//无优化return0;}

6.2 返回优化

6.2.1 创建对象再返回

A f3(){
    A a;return a;}intmain(){f3();//无优化，因为在不同表达式
    A a1 =f3();//构造+两次拷贝构造——》优化为构造+拷贝构造

    A a3;
    a3 =f3();//思考这种写法与上述写法的区别return0;}

6.2.2 返回匿名对象

A f4(){returnA();}intmain(){f4();//构造+拷贝构造——》优化为构造
    A a2 =f4();//构造+两次拷贝构造——》优化为构造return0;}

6.3 优化总结

6.3.1 函数传参

  • 尽量使用const &传参

6.3.2 对象返回

  1. 接收返回对象，尽量以拷贝构造方式接收，不要赋值接收
  2. 函数中返回对象时，尽量返回匿名对象

七、再次理解封装

现实生活中的实体计算机并不认识，计算机只认识二进制格式的数据。如果想要让计算机认识现实生活中的实体，用户必须通过某种面向对象的语言，对实体进行描述，然后通过编写程序，创建对象后计算机才可以认识。

在类和对象阶段，大家一定要体会到，类是对某一类实体(对象)来进行描述的，描述该对象具有那些属性，那些方法，描述完成后就形成了一种新的自定义类型，才用该自定义类型就可以实例化具体的对象。

总结

至此，类和对象章节结束。而从此刻开始，才算是真正进入C++的大门！之所以有人说C++难学，大概就是前期门槛较高，语法繁杂。但是，此刻迈过这道坎，便是轻舟已过万重山。

标签： c++ 开发语言
本文转载自: https://blog.csdn.net/2301_79188764/article/details/134914937
版权归原作者 快乐的流畅 所有， 如有侵权，请联系我们删除。
登录后发布评论

“【C++练级之路】【Lv.4】类和对象（下）（初始化列表，友元，static成员，编译器的优化）”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

机器人技术在安全领域的重要作用

安全学习记录——网络篇（一）

图腾柱PFC：HP1010为您的电动两轮车之旅提供绿色，高效，安全的动力

单元测试数据库回滚问题

这才是单元测试，之前我们都错了

【C语言基础】：字符函数和字符串函数

ChatGPT-Next-Web SSRF漏洞+XSS漏洞复现(CVE-2023-49785)

文章导航