C++初阶——类和对象（下）

目录
一 再探构造函数
二 类型转换
三 static成员
四 友元
五 内部类
六 匿名对象
七 对象拷贝时的编译优化

一、再探构造函数

• 之前实现构造函数时，初始化成员变量主要使用函数体内赋值，构造函数初始化还有一种方法，就是初始化列表
• 每个成员变量在初始化列表中只能初始化一次，语法理解上初始化列表可以认为是每个成员变量定义初始化的地方
• 引用成员变量，const成员变量，没有默认构造的类类型变量，必须放在初始化列表位置初始化，否则会报错
• C++11支持在成员变量声明的位置给缺省值，这个缺省值主要是在初始化列表初始化成员时使用的
• 所有类成员都会走初始化列表，如果该成员在声明时给了缺省值，初始化列表会用缺省值初始化。如果未给缺省值，对于未在初始化列表初始化的内置类型成员是否初始化会取决于编译器。对于未在初始化列表初始化的自定义类型会调用该成员类型的构造函数，没有默认构造会报错
• 初始化列表按照成员变量在类中的声明顺序初始化，与成员在初始化列表出现的先后顺序无关。建议声明顺序与初始化列表顺序保持一致
  需要注意的是：
• 无论是否显式写初始化列表，每个构造函数都有初始化列表；
• 无论是否在初始化列表显式初始化成员变量，每个成员变量都要走初始化列表
  
  初始化列表使用举例：

classQNode{public:QNode(inta=1,QNode*pnext=nullptr)//初始化列表:x(a),next(pnext){}~QNode(){x=0;next=nullptr;}private:QDataType x;QNode*next;};

题目类型举例：
以下程序的输出？

#include<iostream>usingnamespacestd;classA{public:A():_a2(1)//1,_a1(_a2)//2{}//先初始化_a1，先运行2，再运行1，已在初始化列表显式初始化，因此不用缺省值，此时_a2是随机值，//故_a1初始化为随机值，运行2：_a2显式初始化为1voidPrint(){cout<<_a1<<" "<<_a2<<endl;}private:int_a1=2;int_a2=2;};intmain(){A aa;aa.Print();return0;}

以上程序输出为：随机值 1

二、类型转换

C语言类型转换：

• 整型之间
• 整型与浮点型之间
• 整型与指针之间
• 指针之间

以上能互相转换的类型之间都是有关联的。
而在C++里，又存在着内置类型与类类型的转换，类类型之间的转换。

• C++支持内置类型隐式类型转换为类类型对象，需要有相关内置类型为参数的构造函数
• 构造函数前面加explicit就不再支持隐式类型转换
• 类类型的对象之间也可以隐式转换，需要相应的构造函数支持

#include<iostream>usingnamespacestd;classA{public:A(intx):_a1(x){}A(inta,intb):_a1(a),_a2(b){}voidPrint(){cout<<_a1<<" "<<_a2<<endl;}intGeta(){return_a1+_a2;}private:int_a1=1;int_a2=2;};classB{public:B(intx):_b(x){}B(A&aa):_b(aa.Geta()){}voidPrint(){cout<<_b<<endl;}private:int_b=3;};intmain(){//1构造临时对象，用临时对象拷贝构造aa1//有的编译器会将构造+拷贝构造优化为直接构造A aa1=1;//引用临时对象constA&aa2=1;//C++11后支持多参数转化A aa3={2,2};aa1.Print();aa3.Print();//aa3隐式类型转化为bB b=aa3;b.Print();//引用临时对象constB&b2=1;return0;}

三、static成员

• 用static修饰的成员函数称之为静态成员函数，静态成员函数没有this指针
• 静态成员函数可以访问其他静态成员，但不能访问非静态的，因为没有this指针
• 非静态成员函数，可以访问任意的静态成员变量和非静态成员变量
• 突破类域就可以访问静态成员，可以通过类名：：静态成员或对象.静态成员来访问静态成员
• 静态成员也是类的成员，受public，protected，private访问限定符限制
• 静态成员变量不能在声明位置给缺省值初始化，因为缺省值是用于构造函数初始化列表的，静态变量不属于某个对象，不走初始化列表

static成员的应用：实现一个类，计算程序中创建了多少对象？

classA{public:A(){++scount;}A(A&aa){++scount;}~A(){--scount;}intGetcount(){returnscount;}private://类内声明staticintscount;};//类外初始化intA::scount=0;

static成员的应用：完成1+2+…+n

#include<iostream>usingnamespacestd;classSum{public:Sum(){++_i;_ret+=_i;}staticintGetret(){return_ret;}~Sum(){}private:staticint_i;staticint_ret;};intSum::_i=0;intSum::_ret=0;intmain(){intn;cin>>n;Sum*s=newSum[n];cout<<Sum::Getret()<<endl;return0;}

四、友元

• 友元提供了一种突破类访问限定符封装的方式，友元分为：友元函数和友元类，在函数声明或类声明的前面加friend，并把友元声明放到一个类里面
• 外部友元函数可访问类的私有和保护成员，友元函数仅仅是一种声明，他不是类的成员函数
• 友元函数可以定义在类定义的任何地方声明，不受类访问限定符限制
• 一个函数可以是多个类的友元
• 友元类中的成员函数都可以是另一个类的友元函数，都可以访问另一个类中的私有和保护
• 友元关系是单向的，无交换性，比如A类是B类的友元，但是B类不是A类的友元
  友元类关系不能传递，若A是B的友元，B是VC的友元，但A不是C的友元
• 有时友元提供了便利。但是友元会增加耦合度，破坏了封装，所以友元不宜多用

//友元函数classB;//提前声明，否则A内的友元函数声明编译器找不到BclassA{public:friendvoidfunc(constA&a,constB&b);private:int_aa1=1;int_aa2=2;};classB{public:friendvoidfunc(constA&a,constB&b);private:int_bb1=3;int_bb2=4;};voidfunc(constA&a,constB&b){cout<<a._aa1<<" "<<a._aa2<<endl;cout<<b._bb1<<" "<<b._bb2<<endl;}

//友元类classA{public:friendclassB;private:int_aa1=1;int_aa2=2;};classB{public:voidPrint(constA&a){cout<<a._aa1<<" "<<a._aa2;}private:int_bb1=3;int_bb2=4;};

五、内部类

• 如果一个类定义在另一个类内部，这个内部类就叫内部类。内部类是一个独立的类，跟定义在全局相比，他只是受外部类类域限制和访问限定符限制，所以外部类定义的对象不包括内部类
• 内部类默认是外部类的友元
• 内部类本质也是一种封装，当A类跟B类紧密关联，A类实现出来主要就是给B类使用，那么可以考虑把A类设计为B类的内部类，若将A放到私有和保护，那么A类就是B类的专属内部类，其他地方都用不了

1+2+…+n题目解答的另一种形式：

#include<iostream>usingnamespacestd;classSolution{//内部类classSum{public:Sum(){++_i;_ret+=_i;}};staticint_i;staticint_ret;public:intGetSum(){intn;cin>>n;Sum*p=newSum[n];return_ret;}};intSolution::_i=0;intSolution::_ret=0;

六、匿名对象

• 用类型定义出来的对象叫做匿名对象，之前我们定义的 类型 对象名 叫有名对象
• 匿名对象的生命周期只在当前一行，一般临时定义一个对象当前用一下即可，就可以定义匿名对象

举例：

classA{...};intmain(){A();A(1);return0;}

七、对象拷贝时的编译器优化

• 现代编译器为尽可能提高程序效率，在不影响正确性的前提下，会尽可能减少一些传参和传返回值过程中可省略的拷贝
• 如何优化C++标准未严格规定，各编译器会自行处理。当前主流编译器对于连续一个表达式步骤中的连续拷贝会进行合并优化，有些更新的编译器还会进行跨行跨表达式的合并优化
• linux下可将下面代码拷贝到test.cpp文件中，编译时用g++ test.cpp -fno-elide-constructors 的方式关闭构造相关的优化
  对以下的A类：

classA{public:A(inta=0):_a1(a){cout<<"A(int a)"<<endl;}A(constA&aa):_a1(aa._a1){cout<<"A(const A& aa)"<<endl;}A&operator=(constA&aa){cout<<"A& operator=(const A& aa)"<<endl;if(this!=&aa){_a1=aa._a1;}return*this;}~A(){cout<<"~A()"<<endl;}private:int_a1=1;};Af2(){A aa;returnaa;}

根据编译器优化构造的方式，我们可以在写程序时得到一些启示：

1. 尽量传参不传有名对象，可用匿名对象或类型转换
2. 推荐写法：

A aa1=f2();

不推荐写法：

A aa1;aa1=f2();