【C++基础】三、类和对象（中篇）

如果一个类别中没有成员，它被称为空类。空类中什么都没有吗？不，任何类别都会自动生成以下动生成以下六个默认成员函数。

 class Date { 
         }; 

构造函数：在对象构造中调用的函数完成初始化

#include<iostream> using namespace std; class Date { 
         public:  //void Display(Date* this)  void Display()  { 
           cout << _year << "-" << _month << "-" << _day << endl;   //cout << this->_year << "-" << this->_month << "-" <<this-> _day << endl;  }  //void SetDate(Date* this,int year,int month,int day)  void SetDate(int year, int month, int day)  { 
           _year = year;//this->_year = year;   _month = month;//this->_month = year;   _day = day;//this->_day = year;  } private:  int _year;//年  int _month;//月  int _day;//日 }; int main) { 
          Date d1, d2; d1.SetDate(2021, 8, 19);//d1.SetDate(&d1,2021,8,19) d2.SetDate(2021, 8, 20);//d2.SetDate(&d2,2021,8,19) d1.Display();//d1.Display(&d1) d2.Display();//d2.Display(&d2) return 0; } 

对于Date类，可以通过SetDate公有的方法给对象设置内容，但是如果每次创建对象都调用该方法设置信息，未免有点麻烦，那能否在对象创建时，就将信息设置进去呢?

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

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

其特征如下:

1.函数名与类名相同

2.无返回值。

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

4.构造函数可以重载。

#include<iostream>
using namespace std;
class Date
{ 
        
public:
	//void Display(Date* this)
	void Display()
	{ 
        
		cout << _year << "-" << _month << "-" << _day << endl;
		//cout << this->_year << "-" << this->_month << "-" <<this-> _day << endl;
	}
	//void SetDate(Date* this,int year,int month,int day)
	void SetDate(int year, int month, int day)
	{ 
        
		_year = year;//this->_year = year;
		_month = month;//this->_month = year;
		_day = day;//this->_day = year;
	}
	//构造函数 相当于SetDate，初始化，但是由程序自动调用，不需要我们去调用
	//1.无参数构造函数
	Date() { 
        
		_year = 0;
		_month = 1;
		_day = 1;
	}
	//2.带参数构成函数 无参和带参两种方式均可
	Date(int year, int month, int day) { 
        
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;//年
	int _month;//月
	int _day;//日
};
int main()
{ 
        
	Date d1(2021, 8, 21);
	d1.Display();
	d1.SetDate(2021, 10, 1);
	d1.Display();

	Date d2;
	d2.Display();

	//Date d1;//调用无参构造函数 注意后面不能带（），否则变成函数声明了
	//Date d2(2015, 1, 1);//调用带参的构造函数

	//d1.SetDate(2021, 8, 19);//d1.SetDate(&d1,2021,8,19)
	//d2.SetDate(2021, 8, 20);//d2.SetDate(&d2,2021,8,19)
	//d1.Display();//d1.Display(&d1)
	//d2.Display();//d2.Display(&d2)
	return 0;
}

Date d2;//后面不能加(),d2(),这是语法规定的

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

这句话的意思就是”如果我们定义了构造函数，那么C++编译器就会使用我们定义的构造函数来初始化新建的对象；如果我们没有定义构造函数，那么C++编译器会自动生成一个没有参数的默认构造函数，然后用这个默认构造函数去初始化新建的对象。”

看起来编译器默认构造函数啥也没干，还是随机值，那这个默认构造函数有啥用呢？

前面通过构造函数的学习，我们知道一个对象时怎么来的，那一个对象又是怎么没呢的?

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

析构：对象生命周期到了以后，自动调用。完成对象里面的资源清理（资源：对象创建时向系统申请的空间，比如所 malloc 出来的空间）

析构函数是特殊的成员函数。其特征如下:

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

2.无参数无返回值

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

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

#include<iostream>
using namespace std;
class Date
{ 
        
public:
	//构造函数
	Date(int year = 0, int month = 1, int day = 1) { 
        
		_year = year;
		_month = month;
		_day = day;
		cout << "自动调用构造函数" << endl;
	}
	//析构函数
	~Date() { 
        
		cout << "自动调用析构函数~" << endl;
	}
	void Display()
	{ 
        
		cout << _year << "-" << _month << "-" << _day << endl;
		//cout << this->_year << "-" << this->_month << "-" <<this-> _day << endl;
	}

private:
	int _year;//年
	int _month;//月
	int _day;//日
};
int main()
{ 
        
	Date d1(2021, 10, 1);
	Date d2;
	d1.Display();
	d2.Display();
	return 0;
}

析构函数什么时候使用呢？

当我们动态开辟数组，比如malloc/colloc/realloc出来的空间，使用之后需要将这些堆上的空间释放掉，就可以利用析构函数将资源清理掉。

#include<iostream>
using namespace std;
class Stack { 
        
public:
	//构造函数，完成初始化
	Stack(int n = 10) { 
        
		_array = (int*)malloc(sizeof(int) * n);
		_size = 0;
		_capacity = 10;
	}
	//析构函数，完成资源清理
	~Stack() { 
        
		free(_array);
		_array = NULL;
		_size = 0;
		_capacity = 0;
	}
private:
	int* _array;
	int _size;
	int _capacity;
};
int main() { 
        
	Stack st;
	return 0;
}

调用构造函数完成初始化

调用析构函数完成资源清理

一个类要有什么样的成员变量和成员函数，需要根据类的实际使用场景来确定。

5.关于编译器自动生成的析构函数，是否会完成一些事情呢?

下面的程序我们会看到，编译器生成的默认析构函数，对会自定类型成员调用它的析构函数。

（类似于构造函数的语法坑：双标狗）

跟构造函数类似，编译器默认生成的析构函数做了偏心的处理：

1）内置类型不处理

2）自定义类型会去调用它的析构函数

#include<iostream>
using namespace std;
class Time { 
        
public:
	~Time() { 
        
		cout << "~Time()" << endl;
	}
private:
	int _hour;
	int _minute;
	int _second;
};
class Date
{ 
        
public:
	//构造函数
	Date(int year = 0, int month = 1, int day = 1) { 
        
		_year = year;
		_month = month;
		_day = day;
		cout << "自动调用构造函数" << endl;
	}
	析构函数
	//~Date() { 
        
	// cout << "自动调用析构函数~" << endl;
	//}
	void Display()
	{ 
        
		cout << _year << "-" << _month << "-" << _day << endl;
		//cout << this->_year << "-" << this->_month << "-" <<this-> _day << endl;
	}

private:
	int _year;//年
	int _month;//月
	int _day;//日
	Time _t;//自定义类型
};
int main()
{ 
        
	Date d1(2021, 10, 1);
	Date d2;
	d1.Display();
	d2.Display();
	return 0;
}

在现实生活中，可能存在长得一模一样的事物，我们称其为双胞胎（孪生/双生）。

那在创建对象时，可否创建一个与一个对象一模一样的新对象呢?

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

拷贝构造函数也是特殊的成员函数，其特征如下:

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

2.拷贝构造函数的参数只有一个且必须使用引用传参，使用传值方式会引发无穷递归调用。

#include<iostream>
using namespace std;
class Date 
{ 
        
public:
	Date(int year = 0, int month = 1, int day = 1)
    { 
        
		_year = year;
		_month = month;
		_day = day;
	}
	//拷贝构造函数
	Date(const Date& d) 
    { 
        
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{ 
        
	Date d1(2021, 10, 1);
	Date d2(2021, 10, 1);
	Date d3(d1);
	return 0;
}

如果不使用引用，在调用拷贝构造函数之前需要先传参，传参的时候要先进行拷贝构造，拷贝构造之前又要先传参….语义上

#include<iostream>
using namespace std;
class Date
{ 
        
public:
	Date(int year = 0, int month = 1, int day = 1) 
    { 
        
		_year = year;
		_month = month;
		_day = day;
	}
	//拷贝构造函数
	Date(const Date d) 
    { 
        
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main() 
{ 
        
	Date d1(2021, 10, 1);
	Date d2(2021, 10, 1);
	Date d3(d1);
	return 0;
}

传参的过程又是一个拷贝构造的调用？这句话怎么理解？

func1(int i) 
{ 
        
	//函数内部代码
}
int main() 
{ 
        
	int j = 0;
	func1(j);//调用func1的时候，要先将j传给i
}

实参传给形参是一个赋值的方式

换成class Date类的话

d1传给d的过程就是一个赋值的过程，但是这个自定义类的赋值不同于内置类型的直接赋值，而是再次通过拷贝构造函数给其赋值，然后就形成了语义上的无穷递归……

传值的方式，实参接收形参传过来的值时，需要创建一个临时对象，就会引发对象的拷贝构造。

而传引用的方式（引用是一个变量的别名）没有传参赋值的这个过程，也就不会形成无穷的递归。

拷贝构造也可以通过类似赋值的方式进行

Date d4 = d1;

Date(const Date &d)这里为什么要加上const的呢？

1）使用const可以保证对象d的内容不被修改

2）如果Date(const Date &d){ };花括号内部代码出错了，比如说写反了，编译器会查出来。

3.若未显示定义，系统生成默认的拷贝构造函数。默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝我们叫做浅拷贝，或者值拷贝。

默认的拷贝构造函数，跟默认的构造和析构函数不太一样，不会去区分内置类型和自定义类型，都会区处理

1）内置类型，字节序的浅拷贝

2）自定义类型，会去调用它的拷贝构造函数完成拷贝

字节序的浅拷贝：就像用 memcpy 函数完成拷贝一样（一个字节接着一个字节的拷贝复制）

Stack St1;
Stack st2(st1);
//同一块空间会释放两次

编译器默认生成的拷贝构造函数并不能解决所有问题，所以需要我们定义深拷贝构造来解决这个问题。

#include<iostream>
using namespace std;
class Date
{ 
        
public:
	Date(int year = 1900, int month = 1, int day = 1)
	{ 
        
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
 };
int main()
{ 
        
	Date d1;
	//这里d2调用默认拷贝构造完成拷贝，d2和d1的值是一样的
	Date d2(d1);
	return 0;
}

4.那么编译器生成的默认拷贝构造函数已经可以完成字节序的值拷贝了，我们还需要自己实现吗?当然像日期类这样的类是没必要的。那么下面的类呢?验证一下试试?

//这里会发现下面的程序会崩溃掉？需要我们以后学了深拷贝去解决
#include<iostream>
using namespace std;
class String
{ 
        
public:
	String(const char* str = "jack")
	{ 
        
		_str = (char*)malloc(str