第二章 类与对象

9.1.2 构造函数的8大特性

例如

class Date
{

public :
 // 1.无参构造函数
 Date ()                                //特性1：函数名与类名相同
 {}                                     //特性2：无返回值
 
 // 2.带参构造函数
 Date (int year, int month , int day )
 {
 _year = year ;
 _month = month ;
 _day = day ;
 }


private :
 int _year ;
 int _month ;
 int _day ;
};


void TestDate()
{
 Date d1;             // 特性3：对象实例化时编译器自动调用对应的构造函数，调用无参构造函数
 Date d2 (2015, 1, 1);// 特性3：对象实例化时编译器自动调用对应的构造函数，调用带参的构造函数
                      // 特性4：构造函数可以重载
 
 // 注意：如果通过无参构造函数创建对象时，对象后面不用跟括号，否则就成了函数声明
 // 以下代码注意与Date d1;区分：作用是声明了d3函数，该函数无参，返回一个日期类型的对象
 Date d3(); 
}

class Date
{
public:

 /*
 // 如果用户显式定义了构造函数，编译器将不再生成
 Date (int year, int month, int day)
 {
 _year = year;
 _month = month;
 _day = day;
 }
 */
private:

 int _year;
 int _month;
 int _day;
};


void Test()
{
 // 特性五：没有定义构造函数，对象也可以创建成功，因此此处调用的是编译器生成的默认构造函数
 Date d; 
}

// 默认构造函数
class Date
{ 

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


private :
 int _year ;
 int _month ;
 int _day ;
};


// 以下测试函数能通过编译吗？
void Test()
{
 Date d1; //不能编译通过，因为这个语句无法确定调用无参构造函数还是全缺省构造函数，默认构造函数 
          //只能有一个
}

class Time
{

public:
	Time()
	{
		_hour = 0;
		_minute = 0;
		_second = 0;
	}

public:
	int _hour;
	int _minute;
	int _second;
};


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


int main()
{
	Date d;

	cout << d._year << " " << d._month << " " << d._day << endl;
	cout << d._t._hour << " " << d._t._minute << " " << d._t._second << endl;

	return 0;
}

输出结果

-858993460 -858993460 -858993460
0 0 0

// 我们看看这个函数，是不是很僵硬？
class Date
{

public:
 Date(int year)
 {
 // 这里的year到底是成员变量，还是函数形参？
 year = year;
 }

private:
 int year;
};


// 所以我们一般都建议这样
class Date
{
public:
 Date(int year)
 {
 _year = year;
 }

private:
 int _year;
};

9.2.析构函数

9.2.1析构函数的概念

9.2.2析构函数的5大特性

例如

typedef int DataType;

class SeqList
{ 

public :
 SeqList (int capacity = 10)
 {
 _pData = (DataType*)malloc(capacity * sizeof(DataType));
 assert(_pData);
 
 _size = 0;
 _capacity = capacity;
 }
 
 ~SeqList()           //特性1：析构函数名是在类名前加上字符 ~
 {                    //特性2：无参数无返回值
 if (_pData)          //特性3：一个类有且只有一个析构函数。若未显式定义，系统会自动生成默认的析              
 {                    //构函数
 free(_pData );       // 释放堆上的空间
 _pData = NULL;       // 将指针置为空
 _capacity = 0;
 _size = 0;
 }

 }
  
private :
 int* _pData ;
 size_t _size;
 size_t _capacity;

};

class String
{

public:
 String(const char* str = "jack")
 {
 _str = (char*)malloc(strlen(str) + 1);
 strcpy(_str, str);
 }
 ~String()
 {
 cout << "~String()" << endl;
 free(_str);
 }

private:
 char* _str;
};


class Person
{
private:
 String _name;
 int _age;
};


int main()
{
 Person p;
 return 0; 
}

输出结果

~String()

class Date
{

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

	Date(const Date& d)   //特性2：拷贝构造函数的参数只有一个且必须使用引用传参，使用传值方式会                       
	{                     //引发无穷递归调用
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}

public:
	int _year;
	int _month;
	int _day;
};


int main()
{
	Date d1;
	Date d2(d1); 

	cout << d2._year << " " << d2._month << " " << d2._day << endl;

	return 0;         
}     

输出结果

1900 1 1

例如

	class Date
	{

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

	public:
		int _year;
		int _month;
		int _day;
	};


	int main()
	{
		Date d1;          // 自动调用默认构造函数
		Date d2(d1);      // 这里d2调用的默认拷贝构造完成拷贝，d2和d1的值是一样的。
		
		cout << d2._year << " " << d2._month << " " << d2._day << endl;
		return 0;
	}

输出结果：

1900 1 1

// 这里会发现下面的程序会崩溃掉？这里就需要以后讲的深拷贝去解决。
class String
{

public:
 String(const char* str = "jack")
 {
 _str = (char*)malloc(strlen(str) + 1);
 strcpy(_str, str);
 }
 ~String()
 {
 cout << "~String()" << endl;
 free(_str);
 }

private:
 char* _str;
};


int main()
{
 String s1("hello");
 String s2(s1);
}

输出结果

这里出现崩溃，原因是对象进行了C++的默认拷贝构造，复制情况如下图所示，先析构 s2（对象构造与析构的关系是栈数据结构中的入栈和出栈的关系，所以对象析构的顺序与对象创建的顺序正好相反），将存有hello的空间先行释放，轮到 s1析构时，hello已经不存在了，因此会出现了崩溃。在这种情况下只能自己写一个拷贝构造函数。

例如

class String
{

public:
	String(const char* str = "jack")
	{
		_str = (char*)malloc(strlen(str) + 1);
		strcpy(_str, str);
	}

	String(const String& s)                         //自定义拷贝函数
	{
		_str = (char*)malloc(strlen(s._str) + 1);
		strcpy(_str, s._str);
	}

	~String()
	{
		free(_str);
	}

public:
	char* _str;
};


int main()
{
	String s1("hello");
	String s2(s1);
	cout << s2._str<< endl;
}

输出结果

hello

上面的现象就涉及到一个知识点就是浅拷贝和深拷贝。

5.浅拷贝和深拷贝

5.1 浅拷贝和深拷贝的定义

浅拷贝：简单的赋值拷贝 *** 作。

深拷贝：在堆区重新申请空间，进行拷贝 *** 作。

现在假设创建一个旧类，再把旧类拷贝给新类来创建新类。系统默认拷贝函数和自定义拷贝函数的区别就是，默认的拷贝函数对于自定义类型，是将自定义变量的地址赋给新类的自定义变量，因此新旧两个类的自定义变量都指向同一块堆空间，当程序运行结束自动调用析构函数时，同一块堆空间会被释放两次(新旧类都会释放一次)，因此会发生重复释放空间的错误；而自定义拷贝函数是我们重新在堆上申请一块空间，然后将旧类的自定义变量的值赋给新类的自定义变量，因此新旧两个类的自定义变量指向不同的堆空间，当程序运行结束自动调用析构函数时就不会发生重复释放空间的错误，他们各自释放各自的堆空间。

对于基本类型变量，默认拷贝函数和自定义拷贝函数都是在栈上重新开辟空间，然后传值给新类的基本类型变量，因此基本类型变量调用默认拷贝函数或自定义拷贝函数都是没问题的。

总结：如果类中有在堆区开辟的的变量，则一定要自己写拷贝构造函数，防止浅拷贝带来的问题。

6. 补充语法讲解

6.1初始化列表

作用：C++提供了初始化列表语法，用来初始化属性

语法：构造函数() : 属性1(值1) ; 属性2(值2) . . .{} 

例如

class Person
{
	public:
		//传统的初始化 *** 作
		/*Person(int a, int b, int c)
		{
			m_A = a;
			m_B = b;
			m_C = c;
		}*/


		//使用初始化列表进行初始化，版本1（初始化数据写死无法更改）
		/*Person() :m_A(10), m_B(20), m_C(30)
		{
			
		}*/


		//使用初始化列表进行初始化，版本2（使用变量传值）
		Person(int a, int b, int c) :m_A(a), m_B(b), m_C(c)
		{

		}


		int m_A;
		int m_B;
		int m_C;
};


int main()
{
	//传统的初始化 *** 作
	/*Person p(10, 20, 30);
	cout << p.m_A << " " << p.m_B << " " << p.m_C << " " << endl;*/

	//使用初始化列表进行初始化，版本1
	/*Person p;
	cout << p.m_A << " " << p.m_B << " " << p.m_C << " " << endl;*/


	//使用初始化列表进行初始化，版本2
	Person p(10, 20, 30);
	cout << p.m_A << " " << p.m_B << " " << p.m_C << " " << endl;

	return 0;
}

依次传统初始化、版本1、版本2，可以发现结果是一样的。

输出结果

10 20 30

6.2 类对象作为类成员

例如

//手机类
class Phone
{
public:
	Phone(string pname)
	{
		cout << "Phone构造函数调用" << endl;
		m_pname = pname;
	}

	~Phone()
	{
		cout << "Phone析构函数调用" << endl;
	}

	//手机名称
	string m_pname;
};


class Person
{
public:

	Person(string name, string pname):m_name(name), m_phone(pname)  //上面将的初始化列表
	{
		cout << "Person构造函数调用" << endl;
	}

	~Person()
	{
		cout << "Person析构函数调用" << endl;
	}


	//姓名
	string m_name;
	//手机
	Phone m_phone;
};


int main()
{
	Person p("张三", "华为");
	cout << p.m_name << " " << p.m_phone.m_pname << endl;

	return 0;
}

输出结果

Phone构造函数调用
Person构造函数调用
张三 华为
Person析构函数调用
Phone析构函数调用

从上面的输出结果就就可以知道，当类中包含类对象时，它的构造和析构函数的调用顺序。

6.3 类中的静态成员

静态成员就是在成员变量和成员函数前加上关键字static，称为静态成员

静态成员分为：

①静态成员变量

Ⅰ.所有对象共享同一份数据

Ⅱ.在编译阶段分配内存

Ⅲ.类内声明，类外初始化

②静态成员函数

Ⅰ.所有对象共享一个函数

Ⅱ.静态成员函数只能访问静态成员变量

①静态成员变量

//静态成员变量
class Person
{
public:

	static int m_A;           //类内声明

	//静态成员变量也是有访问权限的
private:
	static int m_B;           //类内声明

};

int Person::m_A = 100;        //类外初始化

int Person::m_B = 200;        //类外初始化


void test1()
{
	//1.所有对象都共享同一份数据
	//2.编译阶段就分配内存
	//3.类内声明，类外初始化 *** 作

	//演示如下
	
	//100
	Person p1;
	cout << p1.m_A << endl;         //输出p1.m_A

	//200
	Person p2;
	p2.m_A = 200;                   //给p2.m_A赋值
	cout << p1.m_A << endl;         //但依然用输出p1.m_A
}


void test2()
{
	//静态成员变量不属于某个对象上，所有对象都共享同一份数据
	//因此静态成员变量有两种访问方式

	//1.通过对象进行访问
	Person p1;
	cout << p1.m_A << endl;

	//2.由于m_A属于静态区，所有可以不创建对象直接通过类名进行访问
	cout << Person::m_A << endl;

}




/*void test3()
{
	cout << Person::m_B << endl;
}*/


int main()
{
	//test1();

	//test2();

	//test3();

	return 0;
}

输出结果依次为

test1();

100
200

test2();

100
100

test3();报错，无法访问私有成员。

②静态成员函数

//静态成员函数
//1.所有对象共享同一个函数
//2.静态成员函数只能访问静态成员变量

class Person
{
public:
	//静态成员函数
	static void func1()
	{
		m_A = 100;                               //静态成员函数可以访问静态成员变量
	  //m_B = 200;                               //静态成员函数不可以访问静态变量，此行代码会报错，因为无法区分到底是哪个对象的m_B
		cout << "static void func调用" << endl;
	}

	//静态成员变量
	static int m_A;    //类内声明
	//非静态成员变量
	int m_B;


	//静态成员函数也是有访问权限的
private:
	static void func2()
	{
		cout << "static void func2调用" << endl;
	}
};

int Person::m_A = 0;   //类外初始化

void test1()
{
	//1.通过对象访问;
	Person p;
	p.func1();

	//2.通过类名访问
	Person::func1();

	//3.类外无法调用私有静态函数
	//Person::func2();               //此行代码会报错，类外无法访问私有函数
}


int main()
{
	//静态成员函数的两种调用方式
	test1();

	return 0;
}

输出结果

test1

100

100

9.5 赋值运算符重载

所谓重载，就是赋予新的含义。函数重载（Function Overloading）可以让一个函数名有多种功能，在不同情况下进行不同的 *** 作。运算符重载（Operator Overloading）也是一个道理，同一个运算符可以有不同的功能。

实际上，我们已经在不知不觉中使用了运算符重载。例如，+号可以对不同类型（int、float 等）的数据进行加法 *** 作；<<既是位移运算符，又可以配合 cout 向控制台输出数据。C++本身已经对这些运算符进行了重载。
C++ 也允许程序员自己重载运算符，这给我们带来了很大的便利。

9.5.2 加号运算符重载

9.5.2.1 加号运算符重载的作用

作用：实现两个自定义数据类型相加的运算

9.5.2.2 加号运算符的实现

//加号运算符重载
//1.通过成员函数重载 + 号
//2.通过全局函数重载 + 号


class Person
{
public:
	//1.通过成员函数重载 + 号
	/*Person operator+(Person& p)
	{
		Person temp;
		temp.m_A = p.m_A + p.m_A;
		temp.m_B = p.m_B + p.m_B;
		return temp;
	}*/

	int m_A;
	int m_B;
};


//2.通过全局函数重载 + 号
Person operator+(Person& p1, Person& p2)
{
	Person temp;
	temp.m_A = p1.m_A + p2.m_A;
	temp.m_B = p1.m_B + p2.m_B;
	return temp;
}


//3.通过全局函数重载 + 号，实现类与整型相加
Person operator+(Person& p1, int x)
{
	Person temp;
	temp.m_A = p1.m_A + x;
	temp.m_B = p1.m_B + x;
	return temp;
}


void test1()
{
	Person p1;
	p1.m_A = 10;
	p1.m_B = 10;

	Person p2;
	p2.m_A = 10;
	p2.m_B = 10;


	//1.成员函数调用重载运算符的本质Person p3=p1.operator+(p2);即p1调用自己的成员函数operator+，将p2传给p1
	//2.全局函数调用重载运算符的本质Person p3=operator+(p1,p2);即调用全局函数operator+，将p1,p2传给p3
	Person p3 = p1 + p2;      //等价于Person p3=p1.operator+(p2)或Person p3=operator+(p1,p2)

	//3.通过全局函数重载 + 号，实现类与整型相加
	Person p4 = p1 + 100;


	cout << p3.m_A << endl;
	cout << p3.m_B << endl;

	cout << p4.m_A << endl;
	cout << p4.m_B << endl;
}


int main()
{
	test1();
	return 0;
}

注意：对于内置的数据类型的表达式的运算符是不可能改变的。

9.5.3 左移运算符重载

9.5.3.1 左移运算符重载的作用

作用：可以输出自定义的类型

9.5.3.2 左移运算符的实现

//左移运算符重载
//1.利用全局函数来实现左移运算符重载(注意：成员函数无法实现左移运算符重载)

class Person
{
	friend ostream& operator <<(ostream& cout, Person& p);    //友元

public:
	Person(int a, int b)
	{
		m_A = a;
		m_B = b;
	}
private:
	int m_A;
	int m_B;
};

//2.实现左移运算符重载
ostream& operator <<(ostream& cout, Person& p)      //本质 operator<<(cout,p) 简化 cout<

//重载递增运算符
//自定义整型

class MyInteger
{
	friend ostream& operator << (ostream& cout, MyInteger myint);
public:
	MyInteger()
	{
		m_Num = 0;
	}


	//2.重载前置++运算符
	MyInteger& operator++()
	{
		//先进行++运算
		m_Num++;

		//再返回自身
		return *this;
	}


	//3.重载后置++运算符
	MyInteger operator++(int)    //其中int代表占位参数，只有这样才能与上面的operator++构成重载
	{
		//先记录当时结果
		MyInteger temp = *this;

		//后递增
		m_Num++;

		//最后将记录结果返回
		return temp;
	}

private:
	int m_Num;
};

//1.重载<<左移运算符
ostream& operator << (ostream & cout, MyInteger myint)
{
	cout << myint.m_Num;
	return cout;
}


void test1()
{
	MyInteger myint1;
	cout << myint1 << endl;          //1.1
	cout << ++myint1 << endl;        //1.2
}


void test2()
{
	MyInteger myint2;
	cout << myint2++ << endl;        //2.1
	cout << myint2 << endl;          //2.2
}


int main()
{
	test1();
	test2();
	return 0;
}

class Person
{
public:
	Person(int age)
	{
		m_age = new int(age);        //在堆区申请空间
	}
	int* m_age;

	~Person()
	{
		if (m_age != NULL)
		{
			delete m_age;
			m_age = NULL;
		}
	}

	//重载 赋值运算符                    //2.自定义重载赋值运算符
	Person& operator=(Person& p)
	{
		//编译器提供浅拷贝
		//m.age = p.m_age;

		//应该先判断是否属性在堆区，如果有先释放干净，然后再深拷贝
		if (m_age != NULL)
		{
			delete m_age;
			m_age = NULL;
		}

		//深拷贝
		m_age = new int(*p.m_age);
		return *this;
	}

};


void test1()
{
	Person p1(10);
	cout << "p1=" << *(p1.m_age) << endl;

	Person p2(20);
	cout << "p2=" << *(p2.m_age) << endl;

	//p2 = p1;                            //1.由于浅拷贝，程序运行结束时会报错
	//cout << *(p2.m_age) << endl;

	p2 = p1;                            //2.自定义重载赋值运算符后，程序运行结束时不会报错
	cout << "p2=" << *(p2.m_age) << endl;

	Person p3(30);
	cout << "p3=" << *(p3.m_age) << endl;

	p3 = p2 = p1;
	cout << "p3=" << *(p3.m_age) << endl;

}


int main()
{
	test1();
	return 0;
}

class Person
{
public:
	Person(string name, int age)
	{
		m_name = name;
		m_age = age;
	}

	//重载等号
	bool operator==(Person& p)
	{
		if (this->m_name == p.m_name && this->m_age == p.m_age)
		{
			return true;
		}
		else
		{
			return false;
		}
	}

	bool operator!=(Person& p)
	{
		if (this->m_name == p.m_name && this->m_age == p.m_age)
		{
			return false;
		}
		else
		{
			return true;
		}
	}


	string m_name;
	int m_age;
};

void test1()
{
	Person p1("Tom", 18);
	Person p2("Tom", 18);

	if (p1 == p2)
	{
		cout << "p1和p2是相等的！" << endl;
	}
	else
	{
		cout << "p1和p2是不相等的！" << endl;
	}
}

void test2()
{
	Person p1("Tom", 18);
	Person p2("Jack", 18);

	if (p1 == p2)
	{
		cout << "p1和p2是相等的！" << endl;
	}
	else
	{
		cout << "p1和p2是不相等的！" << endl;
	}
}

void test3()
{
	Person p1("Tom", 18);
	Person p2("Tom", 18);

	if (p1 != p2)
	{
		cout << "p1和p2是不相等的！" << endl;
	}
	else
	{
		cout << "p1和p2是相等的！" << endl;
	}
}

void test4()
{
	Person p1("Tom", 18);
	Person p2("Jack", 18);

	if (p1 != p2)
	{
		cout << "p1和p2是不相等的！" << endl;
	}
	else
	{
		cout << "p1和p2是相等的！" << endl;
	}
}

int main()
{
	test1();
	test2();
	test3();
	test4();
	return 0;
}

//函数调用运算符重载

//1.函数调用运算重载_字符串函数重载
class MyPrint
{
public:
	//重载函数调用运算符
	void operator()(string test)
	{
		cout << test << endl;
	}
};


//1.测试打印函数
void test1()
{
	MyPrint myprint;
	myprint("hello world");
}


//2.函数调用运算重载_字符串函数重载
class MyAdd
{
public:
	int operator()(int num1, int num2)
	{
		return num1 + num2;
	}
};


//2.测试相加函数
void test2()
{
	MyAdd myadd;
	int ret = myadd(10, 10);
	cout << ret << endl;
}


//3.匿名对象调用函数
void test3()
{
	cout << MyAdd()(100, 100) << endl;
}


int main()
{
	test1();
	test2();
	test3();
	return 0;
}