【C++初阶】—— 类和对象 (中）

最新推荐文章于 2024-06-17 21:54:57 发布

Eternity._

最新推荐文章于 2024-06-17 21:54:57 发布

阅读量1.7k

点赞数 72

分类专栏： C++ “ 登神长阶 ” 文章标签： c++ 开发语言学习

本文链接：https://blog.csdn.net/EterNity_TiMe_/article/details/139124164

版权

C++ “ 登神长阶 ” 专栏收录该内容

18 篇文章 3 订阅

订阅专栏

📝个人主页🌹：EterNity_TiMe_
⏩收录专栏⏪：C++ “ 登神长阶 ”
🌹🌹期待您的关注 🌹🌹

在这里插入图片描述

前言：在参透了类的相关知识后，我们来进一步了解类的6个默认成员函数，本篇先让我们了解三个，剩下的将会在下一篇展开

在这里插入图片描述

如果你还没弄清类的基础知识建议先阅读这篇文章
类的基础知识

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

1. 构造函数

构造函数的概念

构造函数： 是一个特殊的成员函数，名字与类名相同,创建相同类型对象时由编译器自动调用，用来初始化对象

构造函数可以重载
例如：

class Date
{
public:
	// 无返回值，名字与类名相同，用来初始化对象
	// 带参构造函数
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	// 无参构造函数
    Date()
    {}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1; // 调用无参构造函数
	Date d2(2024,5,22); // 调用带参构造函数
}

注意： 如果通过无参构造函数创建对象时，对象后面不用跟括号，否则就成了函数声明

构造函数的特征

注意：

构造函数是特殊的成员函数，与一般的函数不同
构造函数的主要任务不是开空间创建对象，而是初始化对象。

如果类中没有显式定义构造函数，系统就会自动生成一个默认构造函数

class Date
{
public:
	// 当我们没有写构造函数时，系统会直接生成默认构造
	//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类中构造函数屏蔽后，代码可以通过编译，因为编译器生成了一个无参的默认构造函数
将Date类中构造函数放开，代码编译失败，因为一旦我们自己定义任何构造函数，编译器将不再生成

C++11 中针对内置类型成员不初始化的缺陷做出了改变，内置类型成员变量在类中声明时可以给默认值。

class Date
{
public:
	void Print()
 	{
	 	cout << _year << "-" << _month << "-" << _day << endl;
 	}
private:
	int _year = 2024;
	int _month = 5;
	int _day = 22;
};
int main()
{
	Date d1; 
	d1.Print(); //打印出日期：2024,5,22
}

默认构造函数

谈了这么久，我们知道了系统还会生成默认构造函数，那默认构造函数到底有什么用呢？不实现构造函数，默认构造初始化的对象将会是随机值，看起来好像默认构造一无是处!真的是这样吗？

C++把类型分成内置类型和自定义类型。内置类型就是语言提供的数据类型，而自定义类型就是我们自己定义的类型，我们看看以下代码

class pxt
{
public:
	pxt()
	{
		cout << "pxt()" << endl;
		_age = 0;
		_id = 0;
		_QQ = 0;
	}
private:
	int _age;
	int _id;
	int _QQ;
};
class Date
{
private:
	// 内置类型
	int _year;
	int _month;
	int _day;
	// 自定义类型
	pxt _t;
};
int main()
{
	Date d;
	return 0;
}

我们发现编译器对内置类型没做处理，生成默认的构造函数会对自定义类型成员_t调用的它的默认成员函数。

注意： 无参构造函数、全缺省构造函数、编译器默认生成的构造函数，都可以认为是默认构造函数。而且无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。

{
public:
 //当实例化对象时没有传参,系统不知道是调用全缺省函数还是无参的函数
     Date()
     {
 	 	_year = 2024;
	 	_month = 5;
	 	_day = 22;
	 }
	 Date(int year = 2024, int month = 5, int day = 22)
 	 {
	 	_year = year;
	 	_month = month;
 		_day = day;
	 }
private:
	 int _year;
 	 int _month;
 	 int _day;
};

2. 析构函数

既然学了构造函数了解对象是怎么来的，必然还要了解一个对象是怎么消失的！

析构函数的概念

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

注意： 析构函数不能重载！！！

析构函数名是在类名前加上字符 ~
例如：

class Date
{
public:
	
	// 构造函数
	Date()
	{
		cout << "Date()" << endl;
	}
	// 析构函数
	// 析构函数无参数无返回值类型
    ~Date()
	{
		cout << "~Date()" << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1; 
}

析构函数的特征

一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数
对象生命周期结束时，C++编译系统系统自动调用析构函数

整体上来说，析构函数就是反向的构造函数其大部分特征都类似，编译器自动生成的默认析构函数也只处理自定义类型，不会管内置类型，那么问题来了如果不去管内置类型不会出问题吗？

其实内置类型会在对象生命周期结束时，它会把栈区的空间还给操作系统，析构函数不处理在栈区的变量也没有问题
但如果是堆区上的空间，这份空间不会主动还给操作系统，必须要我们手动写析构函数来释放

例如：

typedef int DataType;
class Stack
{
public:
	Stack(size_t capacity = 3) // 构造函数
	{
		_array = (DataType*)malloc(sizeof(DataType) * capacity);
		if (NULL == _array)
		{
			perror("malloc false");
			return;
		}
		_capacity = capacity;
		_size = 0;
	}
	//必须要我们手动写析构函数来释放
	~Stack() // 析构函数
	{
		if (_array)
		{
			free(_array);
			_array = NULL;
			_capacity = 0;
			_size = 0;
		}
	}
private:
	DataType* _array;
	int _capacity;
	int _size;
};

int main()
{
	Stack s;
	return 0;
}

因为存在堆区申请的空间，所以不能使用编译器默认生成的析构函数，而是要用自己写的析构函数去释放掉这块空间

默认析构函数

关于编译器自动生成的析构函数，编译器生成的默认析构函数，对自定类型成员调用它的析构函数

class pxt
{
public:
	~pxt()
	{
		cout << "~pxt()" << endl;
	}
private:
	int _age;
	int _id;
	int _QQ;
};
class Date
{
private:
	// 内置类型
	int _year;
	int _month;
	int _day;
	// 自定义类型
	pxt _t;
};
int main()
{
	Date d;
	return 0;
}

在这里插入图片描述
当d的生命周期结束时，系统会自动调用析构函数，而Date类没有自己写析构函数所有就会使用编译器自动生成的默认析构函数，来调用pxt的析构函数

3. 拷贝构造函数

在创建对象时，我们能不能创建一个与已存在对象一某一样的新对象呢？

拷贝构造函数的概念

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

例如：

class Date
{
public:
	Date(int year = 2024, int month = 2, int day = 22)
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1(2024, 5, 20);
	Date d2(d1); //用d1初始化d2
	return 0;
}

同初始化过的同类型对象初始化新对象

拷贝构造函数的特征

拷贝构造函数是构造函数的一个重载形式
拷贝构造函数的参数只有一个且必须是同类型对象的引用

注意：使用传值方式编译器直接报错，因为会引发无穷递归调用

在这里插入图片描述

传引用传参，传实参的别名进函数,就不会发生形参拷贝一份实参的过程，从而不会陷入死循环，因此加上&非常重要！

默认拷贝构造函数

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

注意：浅拷贝要谨慎使用，可能会出现问题

typedef int DataType;
class Stack
{
public:
	Stack(size_t capacity = 10)
	{
		_array = (DataType*)malloc(capacity * sizeof(DataType));
		if (nullptr == _array)
		{
			perror("malloc false");
			return;
		}
		_size = 0;
		_capacity = capacity;
	}
	void Push(const DataType& data)
	{
		// CheckCapacity();
		_array[_size] = data;
		_size++;
	}
	~Stack()
	{
		if (_array)
		{
			free(_array);
			_array = nullptr; 
			_capacity = 0;
			_size = 0;
		}
	}
private:
	DataType* _array;
	size_t _size;
	size_t _capacity;
};
int main()
{
	Stack s1;
	s1.Push(1);
	s1.Push(2);
	s1.Push(3);
	s1.Push(4);
	// 我们没有给出拷贝构造，将调用默认拷贝构造
	Stack s2(s1);
	return 0;
}