【c++】类和对象

目录

1、面向过程和面向对象的区别

1.1面向过程

1.2面向对象

1.3区别

2、class和struct的区别 

2.1类

2.1.1类的定义

2.1.2访问限定符

2.1.3封装

2.1.4类的作用域

2.2结构体

2.3class和struct的区别

3、类大小的计算

3.1内存对齐

3.2空类

4、this指针

4.1this指针

4.2this指针的特性

4.3面试题

5、8个默认成员函数

5.1构造函数

5.1.1概念

5.1.2特性

5.1.3explicit关键字

 5.2析构函数

5.2.1概念

5.2.2特性

5.3拷贝构造函数

5.3.1概念

5.3.2特征

 5.4赋值运算符重载

 5.4.1运算符重载

5.4.2赋值运算符重载

概念

特性

5.4.3前置++和后置++重载

5.5取地址和const取地址操作符重载

5.6移动构造函数和移动赋值函数

5.7总结

5.4初始化列表

5.4.1概念 

5.4.1特性

5.4.2哪些成员必须在初始化列表初始化

6、static成员

6.1概念

6.2特性

7、友元

7.1友元函数

7.2友元类

7.3内部类

7.4匿名对象

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

---

1、面向过程和面向对象的区别

1.1面向过程

C语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。

1.2面向对象

C++是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完 成。

1.3区别

• 面向过程强调的是功能行为，以函数为最小单位，考虑怎么做。
• 面向对象，将功能封装进对象，强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。

2、class和struct的区别 

2.1类

2.1.1类的定义

 class className
 {
     // 类体：由成员函数和成员变量组成
 };  
// 一定要注意后面的分号

 类体中内容称为类的成员：类中的变量称为类的属性或成员变量; 类中的函数称为类的方法或者成员函数。

类的两种定义方式：

1. 声明和定义全部放在类体中，需注意：成员函数如果在类中定义，编译器可能会将其当成内联函数处理。

2. 类声明放在.h文件中，成员函数定义放在.cpp文件中，注意：成员函数名前需要加类名::

一般情况下，更期望采用第二种方式。

2.1.2访问限定符

1. public修饰的成员在类外可以直接被访问

2. protected和private修饰的成员在类外不能直接被访问(此处protected和private是类似的)

3. 访问权限作用域从该访问限定符出现的位置开始直到下一个访问限定符出现时为止

4. 如果后面没有访问限定符，作用域就到}即类结束。

5. class的默认访问权限为private，struct为public(因为struct要兼容C)

注意：访问限定符只在编译时有用，当数据映射到内存后，没有任何访问限定符上的区别

2.1.3封装

面向对象三大特性：继承、封装和多态。

封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来 和对象进行交互。 封装本质上是一种管理，让用户更方便使用类。

2.1.4类的作用域

类定义了一个新的作用域，类的所有成员都在类的作用域中。在类体外定义成员时，需要使用 :: 作用域操作符指明成员属于哪个类域。

2.2结构体

 C语言结构体中只能定义变量，在C++中，结构体内不仅可以定义变量，也可以定义函数。

2.3class和struct的区别

        C++需要兼容C语言，所以C++中struct可以当成结构体使用。另外C++中struct还可以用来定义类，和class定义类是一样的。

区别：

1、struct定义的类默认访问权限是public，class定义的类默认访问权限是private。

2、在继承关系中，struct默认的继承方式是public继承，class默认的继承方式是private继承。 

3、class关键字可以用来定义模板参数，而struct不能。

4、struct一般用于描述一个数据结构集合，而class是对一个对象数据的封装。

3、类大小的计算

3.1内存对齐

类的存储方式：只保存成员变量，成员函数存放在公共的代码段。

一个类的大小，实际就是该类中”成员变量”之和，当然要注意内存对齐。

内存对齐规则：

1. 第一个成员在与结构体偏移量为0的地址处。

2. 其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。 注意：对齐数 = 编译器默认的一个对齐数 与 该成员大小的较小值。 VS中默认的对齐数为8

3. 结构体总大小为：最大对齐数（所有变量类型最大者与默认对齐参数取最小）的整数倍。

4. 如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整 体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。

3.2空类

空类比较特殊，编译器给了空类一个字节来唯一标识这个类的对象。

4、this指针

4.1this指针

C++编译器给每个“非静态的成员函数“增加了一个隐藏 的指针参数，让该指针指向当前对象(函数运行时调用该函数的对象)，在函数体中所有“成员变量” 的操作，都是通过该指针去访问。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成。

4.2this指针的特性

1. this指针的类型：类类型* const，即成员函数中，不能给this指针赋值。

2. 只能在“成员函数”的内部使用

3. this指针本质上是“成员函数”的形参，当对象调用成员函数时，将对象地址作为实参传递给 this形参。所以对象中不存储this指针。

4. this指针是“成员函数”第一个隐含的指针形参，一般情况由编译器通过ecx寄存器自动传递，不需要用户传递。

4.3面试题

1. this指针存在哪里？

this指针是一个形参，一般是存在栈帧里面，VS下一般会用ecx寄存器直接传递。

2. this指针可以为空吗？

this指针可以为空，只要我们不对它进行解引用就不会报错，也就是不需要通过this指向当前对象并对其进行操作时才可以为空。

代码1 

 // 1.下面程序编译运行结果是？  A、编译报错  B、运行崩溃  C、正常运行
 class A
 {
 public:
     void Print()
     {
         cout << "Print()" << endl;
     }
 private:
     int _a;
 };

 int main()
 {
     A* p = nullptr;
     p->Print();
     return 0;
 }

C、正常运行

p->Print(); // 函数在公共代码区，直接用名字去找，指针未解引用

另外两种情况：

p->_a; // 不一定报错，编译器优化了，未生成指令

p->_a=1; // 编译报错

代码2 

 // 1.下面程序编译运行结果是？  A、编译报错  B、运行崩溃  C、正常运行
 class A
 { 
 public:
    void PrintA() 
    {
         cout<<_a<<endl;
    }
 private:
     int _a;
 };

 int main()
 {
     A* p = nullptr;
     p->PrintA();
     return 0;
 }

 B、运行崩溃

 void PrintA() 
 {
      cout<<_a<<endl; // cout<<this->_a<<endl; 指针解引用了，运行崩溃
 }

5、8个默认成员函数

        默认成员函数：用户没有显式实现，编译器会生成的成员函数称为默认成员函数。

5.1构造函数

5.1.1概念

        构造函数是一个特殊的成员函数，名字与类名相同,创建类类型对象时由编译器自动调用，以保证 每个数据成员都有 一个合适的初始值，并且在对象整个生命周期内只调用一次。

        构造函数虽然名称叫构造，但是构造函数的主要任 务并不是开空间创建对象，而是初始化对象。

5.1.2特性

1. 函数名与类名相同。

2. 无返回值。（不需要写void）

3. 对象实例化时编译器自动调用对应的构造函数。

4. 构造函数可以重载。（可以写多个构造函数，提供多种初始化方式）

5. 如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显式定义编译器将不再生成。

6、编译器生成默认的构造函数会对自定类型成员调用的它的默认构造函数。（内置类型不会处理，但是c++11支持声明给缺省值）

 //例如
 class Time
 {
 public:
     Time()
     {
         cout << "Time()" << endl;
         _hour = 0;
         _minute = 0;
         _second = 0;
     }
 private:
     int _hour;
     int _minute;
     int _second;
 };

/*
 class Date
 {
 private:
     // 基本类型(内置类型)
     int _year;
     int _month;
     int _day;
     // 自定义类型
    Time _t; //编译器自动调用Time的默认构造函数
 };
*/


 class Date
 {
 private:
     // 基本类型(内置类型)
     int _year = 1970;
     int _month = 1;
     int _day = 1;
     // 自定义类型
     Time _t; //编译器自动调用Time的构造函数
 };

 int main()
 {
     Date d;
     return 0;
 }

注意：C++11 中针对内置类型成员不初始化的缺陷，又打了补丁，即：内置类型成员变量在 类中声明时可以给默认值。（指针也是内置类型）

7. 无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个（多个并存会存在调用二义性）。

注意：无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为是默认构造函数。（即不传参就可以调用）

 8.一般情况都需要我们自己写构造函数决定初始化方式。成员变量全是自定义类型可以不考虑写构造函数。

5.1.3explicit关键字

         构造函数不仅可以构造与初始化对象，对于单个参数或者除第一个参数无默认值其余均有默认值的构造函数，还具有类型转换的作用。

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

隐式类型的转换会产生临时变量，临时变量和匿名对象都具有常属性。 

class Date
{
public:
		// 1. 单参构造函数，没有使用explicit修饰，具有类型转换作用
		// explicit修饰构造函数，禁止类型转换---explicit去掉之后，代码可以通过编译
		explicit Date(int year)
		:_year(year)
	{}
	/*
	// 2. 虽然有多个参数，但是创建对象时后两个参数可以不传递，没有使用explicit修饰，具
   有类型转换作用
   // explicit修饰构造函数，禁止类型转换
   explicit Date(int year, int month = 1, int day = 1)
	: _year(year)
	, _month(month)
	, _day(day)
	{}
	*/
	Date& operator=(const Date& d)
	{
		if (this != &d)
		{
			_year = d._year;
			_month = d._month;
			_day = d._day;
		}
		return *this;
	}
private:
	int _year;
	int _month;
	int _day;
};
void Test()
{
	Date d1(2022);
	// 用一个整形变量给日期类型对象赋值
   // 实际编译器背后会用2023构造一个无名对象，最后用无名对象给d1对象进行赋值
	d1 = 2023; //隐式类型的转换
}

 5.2析构函数

5.2.1概念

        析构函数：与构造函数功能相反，析构函数不是完成对对象本身的销毁，局部对象销毁工作是由编译器完成的。而对象在销毁时会自动调用析构函数，完成对象中资源的清理工作。

        后定义的先析构。

5.2.2特性

1. 析构函数名是在类名前加上字符 ~。

2. 无参数无返回值类型。

3. 一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。

注意：析构函数不能重载（因为无参数）

4. 对象生命周期结束时，C++编译系统系统自动调用析构函数。

5.编译器生成的默认析构函数，对自定类型成员调用它的析构函数。（内置类型成员不处理）

6. 如果类中没有申请资源时，析构函数可以不写，直接使用编译器生成的默认析构函数，比如 Date类；有资源申请时，一定要写，否则会造成资源泄漏，比如Stack类。

5.3拷贝构造函数

5.3.1概念

        拷贝构造函数：只有单个形参，该形参是对本类类型对象的引用(一般常用const修饰)，在用已存在的类类型对象创建新对象时由编译器自动调用。（一个已存在的对象去初始化另一个要创建的对象）

5.3.2特征

1. 拷贝构造函数是构造函数的一个重载形式。

2. 拷贝构造函数的参数只有一个且必须是类类型对象的引用，使用传值方式编译器直接报错， 因为会引发无穷递归调用。

3. 若未显式定义，编译器会生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。

4.类中如果没有涉及资源申请时，拷贝构造函数是否写都可以；一旦涉及到资源申请 时，则拷贝构造函数是一定要写的，否则就是浅拷贝。

5. 拷贝构造函数典型调用场景： 使用已存在对象创建新对象 函数参数类型为类类型对象 函数返回值类型为类类型对象

 5.4赋值运算符重载

 5.4.1运算符重载

        C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其 返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。

函数名字为：关键字operator后面接需要重载的运算符符号。

函数原型：返回值类型 operator操作符(参数列表)

注意：

1、不能通过连接其他符号来创建新的操作符：比如operator@

2、重载操作符必须有一个类类型参数

3、用于内置类型的运算符，其含义不能改变，例如：内置的整型+，不能改变其含义

4、作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐藏的this

5、不能改变操作符操作数个数，一个操作符是几个操作数，那么重载的时候就有几个参数

6、不能重载的运算符（5个）：

:: （作用域限定符）

sizeof

? : （三目运算符）

. （对象变量取其成员）

.*

运算符重载和函数重载的区别：函数重载是对具有相同名称但参数列表不同的函数进行定义，而运算符重载则是对预定义的运算符进行重新定义，使其能够适用于用户自定义类型。两者都是C++中提高代码可读性和灵活性的重要工具，但各自的应用场景和目的有所不同。 

运算符重载的意义：

1、运算符重载允许将标准运算符应用于自定义数据类型的对象。通过运算符重载，可以为这些自定义类型赋予运算符新的功能，使它们能够执行特定的操作。

2、运算符重载也体现了C++的可扩展性，使其更加适应各种复杂的数据结构和算法需求。

3、运算符重载提高了代码的可读性和直观性。

5.4.2赋值运算符重载

概念

赋值运算符重载：两个已经存在的对象进行拷贝 。

参数类型：const T&，传递引用可以提高传参效率

返回值类型：T&，返回引用可以提高返回的效率，有返回值目的是为了支持连续赋值

检测是否自己给自己赋值

返回*this ：要复合连续赋值的含义

特性

1. 赋值运算符只能重载成类的成员函数不能重载成全局函数

原因：赋值运算符如果不显式实现，编译器会生成一个默认的。此时用户再在类外自己实现 一个全局的赋值运算符重载，就和编译器在类中生成的默认赋值运算符重载冲突了，故赋值运算符重载只能是类的成员函数。

2. 用户没有显式实现时，编译器会生成一个默认赋值运算符重载，以值的方式逐字节拷贝。

注意：内置类型成员变量是直接赋值的，而自定义类型成员变量需要调用对应类的赋值运算符重载完成赋值。

3.如果类中未涉及到资源管理，赋值运算符是否实现都可以；一旦涉及到资源管理则必须要实现。

5.4.3前置++和后置++重载

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

	// 前置++：返回+1之后的结果
    // 注意：this指向的对象函数结束后不会销毁，故以引用方式返回提高效率
	Date& operator++()
	{
		_day += 1;
		return *this;
	}

	// 后置++：
	// 前置++和后置++都是一元运算符，为了让前置++与后置++形成能正确重载
	// C++规定：后置++重载时多增加一个int类型的参数，但调用函数时该参数不用传递，编译器自动传递
	// 注意：后置++是先使用后+1，因此需要返回+1之前的旧值，故需在实现时需要先将this保存一份，然后给this + 1
	// 而temp是临时对象，因此只能以值的方式返回，不能返回引用      
	Date operator++(int)
	{
		Date temp(*this);
		_day += 1;
		return temp;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d;
	Date d1(2022, 1, 13);
	d = d1++; // d: 2022,1,13   d1:2022,1,14
	d = ++d1; // d: 2022,1,15   d1:2022,1,15
	return 0;
}

5.5取地址和const取地址操作符重载

        这两个运算符一般不需要重载，使用编译器生成的默认取地址的重载即可，只有特殊情况，才需要重载，比如想让别人获取到指定的内容（不行被取到有效地址）

5.6移动构造函数和移动赋值函数

C++11 新增了两个：移动构造函数和移动赋值运算符重载。 

如果你没有自己实现移动构造函数，且没有实现析构函数 、拷贝构造、拷贝赋值重载中的任 意一个。那么编译器会自动生成一个默认移动构造。默认生成的移动构造函数，对于内置类型成员会执行逐成员按字节拷贝，自定义类型成员，则需要看这个成员是否实现移动构造， 如果实现了就调用移动构造，没有实现就调用拷贝构造。

如果你没有自己实现移动赋值重载函数，且没有实现析构函数 、拷贝构造、拷贝赋值重载中 的任意一个，那么编译器会自动生成一个默认移动赋值。默认生成的移动构造函数，对于内 置类型成员会执行逐成员按字节拷贝，自定义类型成员，则需要看这个成员是否实现移动赋值，如果实现了就调用移动赋值，没有实现就调用拷贝赋值。(默认移动赋值跟上面移动构造完全类似)

如果你提供了移动构造或者移动赋值，编译器不会自动提供拷贝构造和拷贝赋值。

5.7总结

深拷贝的类，一般都要自己写析构、拷贝构造、赋值。
深拷贝的类，也需要实现移动构造和移动赋值。 

5.4初始化列表

5.4.1概念 

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

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

5.4.1特性

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

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

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

5.4.2哪些成员必须在初始化列表初始化

引用成员变量

const成员变量

自定义类型成员(且该类没有默认构造函数时)

 class A
 {
 public:
     A(int a)
         :_a(a)
     {}
 private:
     int _a;
 };

 class B
 {
 public:
     B(int a, int ref)
         :_aobj(a)
         ,_ref(ref)
         ,_n(10)
     {}
 private:
     A _aobj;     // 没有默认构造函数
    int& _ref;    // 引用
    const int _n; // const 
};

6、static成员

6.1概念

声明为static的类成员称为类的静态成员，用static修饰的成员变量，称之为静态成员变量；用 static修饰的成员函数，称之为静态成员函数。静态成员变量一定要在类外进行初始化。

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

class A
{
public:
	A() { ++_scount; }
	A(const A& t) { ++_scount; }
	~A() { --_scount; }
	static int GetACount() { return _scount; }
private:
	static int _scount;
};
int A::_scount = 0;
void TestA()
{
	std::cout << A::GetACount() << std::endl;
	A a1, a2;
	A a3(a1);
	std::cout << A::GetACount() << std::endl;
}

6.2特性

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

2. 静态成员变量必须在类外定义，定义时不添加static关键字，类中只是声明

3. 类静态成员即可用 类名::静态成员 或者 对象.静态成员 来访问

4. 静态成员函数没有隐藏的this指针，不能访问任何非静态成员

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

静态成员函数不可以调用非静态成员函数；

非静态成员函数可以调用类的静态成员函数。

7、友元

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

7.1友元函数

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

class Date
{
	friend ostream& operator<<(ostream& _cout, const Date& d);
	friend istream& operator>>(istream& _cin, Date& d);
public:
	Date(int year = 1900, int month = 1, int day = 1)
		: _year(year)
		, _month(month)
		, _day(day)
	{}
private:
	int _year;
	int _month;
	int _day;
};
ostream& operator<<(ostream& _cout, const Date& d)
{
	_cout << d._year << "-" << d._month << "-" << d._day;
	return _cout;
}
istream& operator>>(istream& _cin, Date& d)
{
	_cin >> d._year;
	_cin >> d._month;
	_cin >> d._day;
	return _cin;
}
int main()
{
	Date d;
	cin >> d;
	cout << d << endl;
	return 0;
}

说明：

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

2、友元函数不能用const修饰（没有this指针）

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

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

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

7.2友元类

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

1、友元关系是单向的，不具有交换性。

比如Time类和Date类，在Time类中声明Date类为其友元类，那么可以在Date类中直接访问Time类的私有成员变量，但想在Time类中访问Date类中私有的成员变量则不行。

2、友元关系不能传递。

如果C是B的友元， B是A的友元，则不能说明C时A的友元。

3、友元关系不能继承。

class Time
{
    // 声明日期类为时间类的友元类，则在日期类中就直接访问Time类中的私有成员变量
    friend class Date;
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;
};

7.3内部类

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

注意：内部类就是外部类的友元类，参见友元类的定义，内部类可以通过外部类的对象参数来访 问外部类中的所有成员。但是外部类不是内部类的友元。

特性：

1. 内部类可以定义在外部类的public、protected、private都是可以的。

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

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

7.4匿名对象

class A
{
public:
	A(int a = 0)
		:_a(a)
	{
		cout << "A(int a)" << endl;
	}
	~A()
	{
		cout << "~A()" << endl;
	}
private:
	int _a;
};
class Solution {
public:
	int Sum_Solution(int n) {
		//...
		return n;
	}
};
int main()
{
	A aa1;

	// 不能这么定义对象，因为编译器无法识别下面是一个函数声明，还是对象定义
    //A aa1();

	// 我们可以这么定义匿名对象，匿名对象的特点不用取名字，
    // 他的生命周期只有这一行，下一行他就会自动调用析构函数
	A();

	// 匿名对象在这样场景下就很好用，当然还有一些其他使用场景，这个我们以后遇到了再说
	Solution().Sum_Solution(10);
	return 0;
}

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

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 f1(A aa)
{}
A f2()
{
	A aa;
	return aa;
}
int main()
{
	// 传值传参
	A aa1;
	f1(aa1);
	
	// 传值返回
	f2();
	
	// 隐式类型，连续构造+拷贝构造->优化为直接构造
	f1(1);

	// 一个表达式中，连续构造+拷贝构造->优化为一个构造
	f1(A(2));
	
	// 一个表达式中，连续拷贝构造+拷贝构造->优化一个拷贝构造
	A aa2 = f2();
	
	// 一个表达式中，连续拷贝构造+赋值重载->无法优化
	aa1 = f2();
	
	return 0;
}

隐式类型，连续构造+拷贝构造->优化为直接构造

一个表达式中，连续构造+拷贝构造->优化为一个构造

一个表达式中，连续拷贝构造+拷贝构造->优化一个拷贝构造

一个表达式中，连续拷贝构造+赋值重载->无法优化