c++类和对象（2）

c++类和对象（2）

文章目录

1.构造函数2.析构函数默认构造函数运算符的重载

赋值运算符的重载

如果我们写了一个空类，那么真的这空类什么都没有吗？
答案并不是
对于任何一个类对象，都有6个默认成员函数

1.构造函数

我们每次写一个类的时候，都很有可能会忘记初始化，所以c++就有默认的构造函数，构造函数就是解决初始化的问题

1.构造函数（特殊的成员函数）
2.他的任务不是开辟空间，而是初始化对象

特征

1.函数名与类名相同
2.没有返回值
3.在对象实例化的时候自动调用
4.构造函数可以重载
5.如果没有显示定义构造函数，编译器会自动生成一个无参的默认函数，一旦用户显示定义编译器将不在生成

class Date
{
public:

	//这可以用缺省参数来合成一个
	//Date()//函数名相同，没有返回值
	//{
	//	year_ = 0;
	//	month_ = 1;
	//	day_ = 1;
	//}
	//Date(int year,int month,int day)//函数重载
	//{
	//	year_ = year;
	//	month_ = month;
	//	day_ = day;
	//}

	Date(int year=0, int month=1, int day=2)//函数重载，全缺省更好用,推荐全缺省或者版半缺省 
	{
		year_ = year;
		month_ = month;
		day_ = day;
	}


private:

	//c++里面把类型分为两类，内置类型（基本类型），自定义类型
	//内置类型，int,double,long ,int arr[]
	//自定义类型：struct class
	//我们不写编译器默认生成的构造函数，对于内置类型不做初始化处理
	//对于自定义类型回去调用他的无参默认构造函数（不用参数就可以调用的）初始化

	//默认构造函数，1.无参的2.全缺省的。3，我们不写，编译器自己默认生成的

	//如果没有默认构造函数就会报错
	int year_;
	int day_;
	int month_;
	A _aa;
};

int main()
{
	//自动调用
	Date d;//这就是对象的实例化
	//year=0,day=1,month=1

	Date d2(2022, 1, 15);
	//year=2022,month=1,day=15
	Date d3(2022);
	Date d4  (2022, 3);




	return 0;
}

2.析构函数

析构函数
不是完成对象的销毁，而是完成对象中资源清理（malloc的free）
特性
1.析构函数的函数名是在这类名前加个~ 如~Date
2.没有参数没有返回值
3.一个类有且只有一个析构函数
4.对象生命周期结束时，c++系统编译会自动调用析构函数

默认生成构造函数和析构函数会对自定义类型成员变量调用他的构造和析构

class Date
{
public:
	Date(int year = 1, int month = 1, int day = 2)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	
	~Date()
	{
		//资源的清理
		cout << "~Date()" << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	//自动调用
	Date d;//这就是对象的实例化
	//year=0,day=1,month=1

	Date d2(2022, 1, 15);
	//year=2022,month=1,day=15
	Date d3(2022);
	Date d4  (2022, 3);
	//结束了就会自动上去调用析构函数
//但是对于Date类没有必要清理，

	Stack   s1;
	Stack s2(4);
	//析构的顺序是相反的,从后往前析构 


	return 0;
}

默认构造函数

拷贝构造函数，是构造函数的重载

概念：是一个特殊的成员函数
函数名和类名相同
如果没有显示构造，系统会生成默认的构造函数
对于内置类型成员会按字节序的拷贝，memcpy，每个字节一次拷贝

总结，拷贝构造是我们不写也会生成的默认拷贝构造函数

//用一个已经存在的成员去初始化一个不存在的成员
Date d(d1)

int main()
{
	Date d1(2022, 11, 9);
	//想去拷贝一下对象，
	//拷贝复制

	//前拷贝
	
	Date d2(d1);//c++里面传值传参就是拷贝构造，用一个同类型对象初始化我，就是拷贝构造，我们不写也会拷贝
	Stack st1(10);
	Stack st2(st1);
	//st2里面的数组地址指向同一个空间，出了作用域st2要析构，要对指向的空间进行析构，但是st1已经析构过了，一块空间不能析构两次
	//导致程序崩溃，应该要有自己独立的空间
	//后面还要学习深拷贝（要我们自己实现拷贝构造函数）

	return 0;
}

运算符的重载

operator

函数名加运算符
返回值是看这个 *** 作符运算后返回的值是什么
参数，有几个 *** 作符，就有 *** 作数，就有几个参数
1.不能通过连接其他的符号来创建新的 *** 作符，比如operator@
2.重载运算符必须有一个类类型参数（必须是自定义类型）
3.我们不能改变他的含义（>不能弄成<）
4.（::） （sizeof） （?） （.） （.*）这些不能重载，经常在笔试题里面出现

//写在类里面，因为有一个隐含的this指针，所以看上去只有一个参数，实际上是有两个，实现和原来运算符一样的功能

	bool operator>(const Date& d2)//==(const Date* this,const Date& d),d1传给this，d2传给d
	{
		if (_year > d2._year)
		{
			return true;
		}
		else if (_month > d2._month)
		{
			return true;
		}
		else if (_year == d2._year && _month == d2._month && _day > d2._day)
		{
			return true;
		}
		else
		{
			return false;
		}
	}

赋值运算符的重载

	Date& operator=(const Date& d)//两个参数
	{

		//极端情况下自己给自己赋值就可以不用处理了，直接判断一下跳过，


		if (this != &d)//如果自己和自己不相等，&d是取地址,this也是指针，用地址去比较
		{
			_year = d._year;
			_month = d._month;
			_day = d._day;
		}
		return *this;//this是指针，*this就是一个d1，返回左 *** 作数
		//会有传值返回就会有调用拷贝构造，所以我们用传引用比较好一点，不会调用拷贝构造
		//出了作用域*this还在，*this就是d1，所以我们传引用返回
	}