当前位置：首页 > article >正文

【C++】类和对象

article 2024/9/27 20:20:48

1. 类的定义

2. 访问限定符

3. 类对象模型

4. this指针

4.1 this指针的引入

4.2 this指针的特性

5. const成员函数

6. 构造、析构、拷贝构造

6.1 构造函数

6.1.1 构造函数的概念

6.1.2 初始化列表

6.1.3 构造函数的特性

6.1.4 explicit关键字

6.2 析构函数

6.2.1 析构函数的概念

6.2.2 析构函数的特性

6.3 拷贝构造函数

6.3.1 拷贝构造函数的概念

6.3.2 拷贝构造函数的特性

7. 构造和析构的调用顺序

8. static成员

8.1 static成员的概念

8.2 static成员的特性

9. 友元

9.1 友元函数

9.2 友元类

10. 内部类

11. 匿名对象

12. 拷贝对象时的一些编译器优化

13. 日期类的实现

13.1 Date.h

13.2 Date.cpp

类的基本思想是数据抽象（ data abstraction）和封装（encapsulation）。数据抽象是一种依赖于接口（interface）和实现（implementation）分离的编程（以及设计）技术。类的接口包括用户所能执行的操作；类的实现则包括类的数据成员、负责接口实现的函数体以及定义类所需的各种私有函数。

封装实现了类的接口和实现的分离。封装后的类隐藏了它的实现细节，也就是说，类的用户只能使用接口而无法访问实现部分。

类要想实现数据抽象和封装，需要首先定义一个抽象数据类型（abstract data type）。在抽象数据类型中，由类的设计者负责考虑类的实现过程；使用该类的程序员则只需要抽象地思考类型做了什么，而无须了解类型的工作细节。

在面向对象的编程中，把用类创建对象的过程称为实例化。

1. 类的定义

class（或struct）类名
{
//类体：由成员函数和成员变量组成
};

class和struct的唯一区别是：class的默认访问权限为private，struct为public（因为struct要兼容C）。

成员变量最好加个前缀或后缀标识。

class Date
{
public:
	void Init(int year, int month, int day)
	{
		year = year;//这里的year是成员变量，还是函数形参？根据局部优先，是函数形参
		month = month;
		day = day;
	}
private:
	int year;
	int month;
	int day;
};

成员变量前加下划线以作标识：

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

类的声明和定义分离：

Date.h：

class Date
{
public:
    //成员函数
	void Init(int year, int month, int day);
private:
    //成员变量
	int _year;
	int _month;
	int _day;
};

Date.cpp：

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

#include "Date.h"

void Date::Init(int year, int month, int day)
{
	_year = year;
	_month = month;
	_day = day;
}

2. 访问限定符

C++实现封装的方式：用类将对象的属性与方法结合在一块，让对象更加完善，通过访问权限选择性的将其接口提供给外部的用户使用。

访问限定符：

public（公有）
protected（保护）
private（私有）

访问限定符说明：

public修饰的成员在类外可以直接被访问
protected和private修饰的成员在类外不能直接被访问（此处protected和private是类似的）
访问权限作用域从该访问限定符出现的位置开始直到下一个访问限定符出现时为止
如果后面没有访问限定符，作用域就到}即类结束。
class的默认访问权限为private，struct为public（因为struct要兼容C）

3. 类对象模型

成员变量在对象中，成员函数不在对象中。每个对象成员变量是不一样的，需要独立存储；每个对象调用成员函数是一样的，放到共享公共区域（代码段）。

class A1
{
public:
    void f1(){}
private:
    int _a;
};
//sizeof(A1)=4

class A2
{
public:
    void f2(){}
};
//sizeof(A2)=1

class A3
{
};
//sizeof(A3)=1

一个类的大小，实际就是该类中“成员变量”之和，当然要注意内存对齐。注意空类的大小，空类比较特殊，编译器给了空类一个字节来唯一标识这个类的对象。

结构体的对齐规则：

第一个成员在与结构体变量偏移量为0的地址处。
其他成员变量要对齐到对齐数的整数倍的地址处。对齐数是编译器默认的一个对齐数与该成员大小的较小值。VS中默认的值为8。
结构体总大小为最大对齐数（每个成员变量都有一个对齐数）的整数倍。
如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。

详见【C语言】自定义类型——结构体、枚举、联合_秋秋晗晗的博客-CSDN博客中1.6 结构体内存对齐。

4. this指针

4.1 this指针的引入

定义一个日期类Date：

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

int main()
{
	Date d1, d2;
	d1.Init(2022, 1, 11);
	d2.Init(2022, 1, 12);
	return 0;
}

Date类中函数体中没有关于不同对象的区分，那当d1调用Init函数时，该函数是如何知道应该设置d1对象，而不是设置d2对象呢？

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

上述日期类由编译器处理后为：

class Date
{
public:
	void Init(Date* const this, int year, int month, int day)
	{
		this->_year = year;
		this->_month = month;
		this->_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1, d2;
	d1.Init(&d1, 2022, 1, 11);
	d2.Init(&d2, 2022, 1, 12);
	return 0;
}

4.2 this指针的特性

this指针的类型：类类型* const，即成员函数中，不能给this指针赋值。
只能在成员函数的内部使用。
this指针本质上是成员函数的形参，当对象调用成员函数时，将对象地址作为实参传递给this形参。所以对象中不存储this指针。
this指针是成员函数第一个隐含的指针形参，一般情况由编译器通过ecx寄存器自动传递，不需要用户传递。

this指针是隐含形参，存储在栈中，VS下面是通过ecx寄存器。

空指针问题：

class Date
{
public:
	void Init(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	//由编译器处理后
	//void Init(Date* const this, int year, int month, int day)
	//{
	//	this->_year = year;
	//	this->_month = month;
	//	this->_day = day;
	//}

	void func()
	{
		cout << "func()" << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date* ptr = nullptr;
	ptr->Init(2022, 2, 2);//运行崩溃 有解引用操作   在公共代码区找到Init函数后，对this有解引用操作
	ptr->func();          //正常运行 没有解引用操作 在公共代码区找到func函数后，对this没有解引用操作
	(*ptr).func();        //正常运行 没有解引用操作 在公共代码区找到func函数后，对this没有解引用操作
	return 0;
}

5. const成员函数

将const修饰的成员函数称之为const成员函数，const修饰类成员函数，实际修饰该成员函数隐含的this指针指向的值，表明在该成员函数中不能对类的任何成员进行修改。

class A
{
public:
	void Print()
	{
		cout << _a << endl;
	}
	//编译器处理后为
	//void Print(A* const this)
	//{
	//	cout << this->_a << endl;
	//}
private:
	int _a = 10;
};

int main()
{
	const A a;
	a.Print();//err 权限放大
	return 0;
}

class A
{
public:
	void Print() const
	{
		cout << _a << endl;
	}
	//编译器处理后为
	//void Print(const A* const this)
	//{
	//	cout << this->_a << endl;
	//}
private:
	int _a = 10;
};

int main()
{
	const A a;
	a.Print();//ok 权限保持
	return 0;
}

内部不改变成员变量的成员函数，最好加上const，const对象和普通对象都可以调用。

6. 构造、析构、拷贝构造

6.1 构造函数

6.1.1 构造函数的概念

对于以下Date类：

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

可以通过Init函数给类对象初始化，但如果每次创建对象时都调用Init函数，未免有点麻烦，那能否在对象创建时，就将信息设置进去呢？

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

class Date
{
public:
    //构造函数
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
};

6.1.2 初始化列表

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

class Date
{
public:
    //传统方式初始化
    Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
    //初始化列表方式初始化
	Date(int year, int month, int day)
		: _year(year)
		, _month(month)
		, _day(day)
	{}
private:
	int _year;
	int _month;
	int _day;
};

每个成员变量在初始化列表中只能出现一次（初始化只能初始化一次）。

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

类中包含以下成员，必须放在初始化列表位置进行初始化：

引用成员变量
const成员变量
自定义类型成员（且该类没有默认构造函数时）

6.1.3 构造函数的特性

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

其特征如下：

函数名与类名相同。
无返回值。
对象实例化时编译器自动调用对应的构造函数。
构造函数可以重载。
如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显式定义编译器将不再生成。
C++把类型分成内置类型（基本类型）和自定义类型。内置类型就是语言提供的数据类型，如：int/char...和任意指针，自定义类型就是我们使用class/struct/union等自己定义的类型。默认生成构造函数对内置类型成员不做处理，对自定义类型成员调用它的默认构造函数。
无参构造函数、全缺省构造函数、编译器默认生成的构造函数，都可以认为是默认构造函数，并且默认构造函数只能有一个。

class Date
{
public:
	//无参构造函数
	Date()
		: _year(2000)
		, _month(8)
		, _day(8)
	{}
	//带参构造函数
	Date(int year, int month, int day)
		: _year(year)
		, _month(month)
		, _day(day)
	{}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1;            //调用无参构造函数
	Date d2(1900, 9, 9);//调用带参构造函数
	Date d3();          //调用无参构造函数的错误写法，对象后面不用加括号，否则就成了函数声明
	return 0;
}

class Time
{
    //...
};

class Date
{
private:
    //内置类型 默认生成构造函数对内置类型成员不做处理
	int _year;
	int _month;
	int _day;
    //自定义类型 默认生成构造函数对自定义类型成员调用它的默认构造函数
    Time _t;
};

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

class Time
{
    //...
};

class Date
{
private:
    //内置类型
	int _year = 2023;
	int _month = 2;
	int _day = 11;
    //自定义类型
    Time _t;
};

6.1.4 explicit关键字

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

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;
};

6.2 析构函数

6.2.1 析构函数的概念

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

在C++中，为了让某个类只能通过new来创建（即如果直接创建对象，编译器将报错），应该：将析构函数设为私有。编译器在栈上创建对象时，如果类的析构函数是私有的，则无法回收栈上的内存。因此无法在栈上创建。

6.2.2 析构函数的特性

析构函数名是在类名前加上字符~。
无参数无返回值类型。
一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。注意：析构函数不能重载。
对象生命周期结束时，C++编译系统系统自动调用析构函数。
默认生成析构函数对内置类型成员不做处理，对自定义类型成员调用它的析构函数。
如果类中没有申请资源时，析构函数可以不写，直接使用编译器生成的默认析构函数，比如Date类；有资源申请时，一定要写，否则会造成资源泄漏，比如Stack类。

6.3 拷贝构造函数

6.3.1 拷贝构造函数的概念

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

6.3.2 拷贝构造函数的特性

拷贝构造函数是构造函数的一个重载形式。
拷贝构造函数的参数只有一个且必须是类类型对象的引用，使用传值方式编译器直接报错，因为会引发无穷递归调用。
若未显式定义，编译器会生成默认的拷贝构造函数。默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。在编译器生成的默认拷贝构造函数中，内置类型是按照字节方式直接拷贝的，而自定义类型是调用其拷贝构造函数完成拷贝的。
类中如果没有涉及资源申请时，拷贝构造函数是否写都可以；一旦涉及到资源申请时，则拷贝构造函数是一定要写的，否则就是浅拷贝，拷贝之后指向同一块空间，会造成：1）插入删除数据会互相影响；2）析构两次、程序崩溃。即自己实现了析构函数释放空间，就需要实现拷贝构造。（浅拷贝：简单的赋值拷贝操作。深拷贝：在堆区重新申请空间，进行拷贝操作。）
拷贝构造函数典型调用场景：1）使用已存在对象创建新对象；2）函数参数类型为类类型对象（形参是实参的临时拷贝）；3）函数返回值类型为类类型对象（传值返回产生临时对象）

以下代码共调用多少次拷贝构造函数：

Widget f(Widget u)
{
    Widget v(u);
    Widget w = v;
    return w;
}

int main()
{
    Widget x;
    Widget y = f(f(x));
    return 0;
}

实例化类对象x时调用的是构造函数。

当编译器不做优化时，共调用9次拷贝构造函数：

实参x传递给形参u（函数参数类型为类类型对象）
Widget v(u);（使用已存在对象创建新对象）
Widget w = v;（使用已存在对象创建新对象）
用w拷贝构造一个临时对象（函数返回值类型为类类型对象）
临时对象传递给形参u（函数参数类型为类类型对象）
Widget v(u);（使用已存在对象创建新对象）
Widget w = v;（使用已存在对象创建新对象）
用w拷贝构造一个临时对象（函数返回值类型为类类型对象）
用临时对象拷贝构造y（使用已存在对象创建新对象）

优化：

4、5合二为一：用w直接拷贝构造u
8、9合二为一：用w直接拷贝构造y

所以优化后共调用7次拷贝构造函数。

7. 构造和析构的调用顺序

析构函数的调用顺序与构造函数相反，即：先构造的后析构，后构造的先析构。

#include <iostream>
using namespace std;

class A
{
public:
	A()
	{
		cout << "A()" << endl;
	}
	~A()
	{
		cout << "~A()" << endl;
	}
private:
	int a = 1;
};

class B
{
public:
	B()
	{
		cout << "B()" << endl;
	}
	~B()
	{
		cout << "~B()" << endl;
	}
private:
	int b = 2;
};

int main()
{
	A a;
	B b;
	return 0;
}

当类对象作为类成员时：

#include <iostream>
using namespace std;

class A
{
public:
	A()
	{
		cout << "A()" << endl;
	}
	~A()
	{
		cout << "~A()" << endl;
	}
private:
	int a = 1;
};

class B
{
public:
	B()
	{
		cout << "B()" << endl;
	}
	~B()
	{
		cout << "~B()" << endl;
	}
private:
	int b = 2;
	A a;//B类中有A类对象
};

int main()
{
	B b;
	return 0;
}

先调用对象成员的构造，再调用本类构造。析构相反。

8. static成员

8.1 static成员的概念

声明为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()
{
	cout << A::GetACount() << endl;
	A a1, a2;
	A a3(a1);
	cout << A::GetACount() << endl;
}

8.2 static成员的特性

静态成员为所有类对象所共享，不属于某个具体的对象，存放在静态区
静态成员变量必须在类外定义，定义时不添加static关键字，类中只是声明
类静态成员即可用类名::静态成员或者对象.静态成员来访问
静态成员函数没有隐藏的this指针，不能访问任何非静态成员
静态成员也是类的成员，受public、protected、private访问限定符的限制

9. 友元

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

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

9.1 友元函数

问题：现在尝试去重载operator<<，然后发现没办法将operator<<重载成成员函数。因为cout的输出流对象和隐含的this指针在抢占第一个参数的位置。this指针默认是第一个参数也就是左操作数了。但是实际使用中cout需要是第一个形参对象，才能正常使用。所以要将operator<<重载成全局函数。但又会导致类外没办法访问成员，此时就需要友元来解决。operator>>同理。

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

	//d1 << cout; -> d1.operator<<(&d1, cout); 不符合常规调用
    //因为成员函数第一个参数一定是隐藏的this，所以d1必须放在<<的左侧
	ostream& operator<<(ostream& _cout)
	{
		_cout << _year << "-" << _month << "-" << _day << endl;
		return _cout;
	}
private:
	int _year;
	int _month;
	int _day;
};

友元函数可以直接访问类的私有成员，它是定义在类外部的普通函数，不属于任何类，但需要在类的内部声明，声明时需要加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;
}

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

9.2 友元类

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

友元关系是单向的，不具有交换性。比如上述Time类和Date类，在Time类中声明Date类为其友元类，那么可以在Date类中直接访问Time类的私有成员变量，但想在Time类中访问Date类中私有的成员变量则不行。

友元关系不能传递。如果C是B的友元， B是A的友元，则不能说明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;
};

10. 内部类

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

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

特性：

内部类可以定义在外部类的public、protected、private都是可以的。
注意内部类可以直接访问外部类中的static成员，不需要外部类的对象/类名。
sizeof(外部类)=外部类，和内部类没有任何关系。

class A
{
private:
	static int k;
	int h;
public:
	class B//B天生就是A的友元
	{
	public:
		void foo(const A& a)
		{
			cout << k << endl;//OK
			cout << a.h << endl;//OK
		}
	};
};

int A::k = 1;

int main()
{
	A::B b;
	b.foo(A());
	return 0;
}

11. 匿名对象

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();
	A aa2(2);
	//匿名对象在这样场景下就很好用
	Solution().Sum_Solution(10);
	return 0;
}

12. 拷贝对象时的一些编译器优化

在传参和传返回值的过程中，一般编译器会做一些优化，减少对象的拷贝，这个在一些场景下还是非常有用的。

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);
	cout << endl;
	//传值返回
	f2();
	cout << endl;
	//隐式类型，连续构造+拷贝构造->优化为直接构造
	f1(1);
	//一个表达式中，连续构造+拷贝构造->优化为一个构造
	f1(A(2));
	cout << endl;
	//一个表达式中，连续拷贝构造+拷贝构造->优化一个拷贝构造
	A aa2 = f2();
	cout << endl;
	//一个表达式中，连续拷贝构造+赋值重载->无法优化
	aa1 = f2();
	cout << endl;
	return 0;
}

对象返回总结：

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

函数传参总结：尽量使用const &传参

13. 日期类的实现

13.1 Date.h

#pragma once

#include <iostream>
#include <assert.h>

using namespace std;

class Date
{
	//友元函数：某些虽然不是类成员却能够访问类的所有成员的函数
	//<<赋值运算符重载
	friend ostream& operator<<(ostream& out, const Date& d);
	//>>赋值运算符重载
	friend istream& operator>>(istream& in, Date& d);
public:
	//获取某年某月的天数
	int GetMonthDay(int year, int month) const;
	//构造函数
	Date(int year = 1900, int month = 1, int day = 1);
	//打印
	void Print() const;
	//==赋值运算符重载
	bool operator==(const Date& d) const;
	//!=赋值运算符重载
	bool operator!=(const Date& d) const;
	//<=赋值运算符重载
	bool operator<=(const Date& d) const;
	//<赋值运算符重载
	bool operator<(const Date& d) const;
	//>=赋值运算符重载
	bool operator>=(const Date& d) const;
	//>赋值运算符重载
	bool operator>(const Date& d) const;
	//日期+=天数
	Date& operator+=(int day);
	//日期+天数
	Date operator+(int day) const;
	//日期-=天数
	Date& operator-=(int day);
	//日期-天数
	Date operator-(int day) const;
	//日期-日期
	int operator-(const Date& d) const;
	//前置++
	Date& operator++();
	//后置++
	Date operator++(int);
	//前置--
	Date& operator--();
	//后置--
	Date operator--(int);
private:
	int _year;
	int _month;
	int _day;
};

//<<赋值运算符重载
inline ostream& operator<<(ostream& out, const Date& d)
{
	out << d._year << "年" << d._month << "月" << d._day << "日" << endl;
	return out;
}

//>>赋值运算符重载
inline istream& operator>>(istream& in, Date& d)
{
	in >> d._year >> d._month >> d._day;
	return in;
}

13.2 Date.cpp

#include"Date.h"

//获取某年某月的天数
int Date::GetMonthDay(int year, int month) const
{
	assert(month > 0 && month < 13);
	int monthArray[13] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
	if (month == 2 && ((year % 4 == 0 && year % 100 != 0) || (year % 400) == 0))
	{
		return 29;
	}
	else
	{
		return monthArray[month];
	}
}

//构造函数
Date::Date(int year, int month, int day)
{
	if (month > 0 && month < 13 && (day > 0 && day <= GetMonthDay(year, month)))
	{
		_year = year;
		_month = month;
		_day = day;
	}
	else
	{
		cout << "日期非法" << endl;
	}
}

//打印
void Date::Print() const
{
	cout << _year << "/" << _month << "/" << _day << endl;
}

//==赋值运算符重载
bool Date::operator==(const Date& d) const
{
	return _year == d._year && _month == d._month && _day == d._day;
}

//!=赋值运算符重载
bool Date::operator!=(const Date& d) const
{
	return !(*this == d);
}

//<=赋值运算符重载
bool Date::operator<=(const Date& d) const
{
	return *this < d || *this == d;
}

//<赋值运算符重载
bool Date::operator<(const Date& d) const
{
	return _year < d._year
		|| (_year == d._year && _month < d._month)
		|| (_year == d._year && _month == d._month && _day < d._day);
}

//>=赋值运算符重载
bool Date::operator>=(const Date& d) const
{
	return !(*this < d);
}

//>赋值运算符重载
bool Date::operator>(const Date& d) const
{
	return !(*this <= d);
}

//日期+=天数
Date& Date::operator+=(int day)
{
	if (day < 0)
	{
		*this -= -day;
		return *this;
	}
	_day += day;
	while (_day > GetMonthDay(_year, _month))
	{
		_day -= GetMonthDay(_year, _month);
		_month++;
		if (_month == 13)
		{
			++_year;
			_month = 1;
		}
	}
	return *this;
}

//日期+天数
Date Date::operator+(int day) const
{
	Date tmp(*this);
	tmp += day;
	return tmp;
}

//日期-=天数
Date& Date::operator-=(int day)
{
	if (day < 0)
	{
		*this += -day;
		return *this;
	}
	_day -= day;
	while (_day <= 0)
	{
		--_month;
		if (_month == 0)
		{
			--_year;
			_month = 12;
		}
		_day += GetMonthDay(_year, _month);
	}
	return *this;
}

//日期-天数
Date Date::operator-(int day) const
{
	Date tmp(*this);
	tmp -= day;
	return tmp;
}

//日期-日期
int Date::operator-(const Date& d) const
{
	Date max = *this;
	Date min = d;
	int flag = 1;
	if (*this < d)
	{
		max = d;
		min = *this;
		flag = -1;
	}
	int n = 0;
	while (min != max)
	{
		++min;
		++n;
	}
	return n * flag;
}

//前置++
Date& Date::operator++()
{
	*this += 1;
	return *this;
}

//后置++
Date Date::operator++(int)
{
	Date tmp(*this);
	*this += 1;
	return tmp;
}

//前置--
Date& Date::operator--()
{
	*this -= 1;
	return *this;
}

//后置++
Date Date::operator--(int)
{
	Date tmp(*this);
	*this -= 1;
	return tmp;
}

查看全文

http://www.kler.cn/news/16172.html