拷贝构造函数,this指针,赋值运算符重载,完整的类

目录

拷贝构造函数

this指针

因为this指针指向本身对象,我们返回this指针就是返回自身对象

 赋值运算符重载(赋值构造函数,这个说法有没有我也忘记了,反正我是一直这么叫的)

完整类(有参,无参,拷贝,赋值,析构)

---

拷贝构造函数

拷贝构造函数(可以理解为构造函数的一种)

若不提供系统会提供默认拷贝构造函数,如果提供则系统不会在提供.

系统提供的默认的拷贝构造函数是浅拷贝.

        浅拷贝,一个地址赋值给另一个地址,两个地址指向同一个空间.释放的时候也就会对同一个空间释放两次,使程序崩溃.

        深拷贝,为要被赋值的地址开辟出源地址指向的空间大小,然后对两个空间进行逐一拷贝.

声明方式与构造函数一样但是参数固定是 const 类的引用

#define _CRT_SECURE_NO_WARNINGS

#include <iostream>
#include <string>

using namespace std;

class Student
{
public:

	//构造函数
	Student(const char* name)
	{
		m_name = new char[strlen(name) + 1];
		strcpy(m_name, name);
	}

	//拷贝构造函数
	Student(const Student& s)
	{
		//浅拷贝	只是赋值的地址为,两个地址指向的是同以块空间
		m_name = s.m_name;	//VS下只是程序崩溃,居然没有保存 这个在GCC环境里一般会报 double free

		//深拷贝
		//m_name = new char[strlen(s.m_name) + 1];
		//strcpy(m_name, s.m_name);
	}

	~Student()
	{
		delete[]m_name;
	}

	void studentShow()const
	{
		cout << m_name << endl;
	}

private:
	char* m_name;
};

int main()
{
	//调用构造函数
	Student s = "hello world";

	//调用拷贝构造
	Student s2(s);
	
	s.studentShow();
	s2.studentShow();

	return 0;
}

拷贝构造函数.其实也是构造函数嘛

值得一说的是,最近看到好几次讨论右值引用的问题,有兴趣的小伙伴可以找找资料.其实这个并不是什么特别新的东西,不知道为啥最近突然火了起来.

除了构造函数,赋值构造函数还有一种移动构造函数.

和右值引用一起看看.建议搜索"移动构造函数和右值引用".

this指针

创建对象的时候,默认生成一个指向当前对象的指针,名为this.

这个指针在类内部使用,上面有在 函数()const 这个const限定的就是this指针

#include <iostream>

using namespace std;

class A
{
public:

	A()
	{
		this->m_a = 10;
		this->m_b = 20;
		this->m_c = 30;
	}

	void aShow()
	{
		//this指针
		cout << this << endl;
		cout << this->m_a << " " << this->m_b << " " << this->m_c << endl;
	}

private:
	int m_a;
	int m_b;
	int m_c;
};

int main()
{
	A a;
	//对象a的地址和 aShow输出的地址是一样的
	cout << &a << endl;
	a.aShow();

	return 0;
}

 

因为this指针指向本身对象,我们返回this指针就是返回自身对象

#include <iostream>

using namespace std;

class A
{
public:

	A()
	{
		this->m_a = 10;
		this->m_b = 20;
		this->m_c = 30;
	}

	void aShow()
	{
		//this指针
		cout << this << endl;
		cout << this->m_a << " " << this->m_b << " " << this->m_c << endl;
	}

	//调用一次让a翻一倍
	A* m_aAdd()
	{
		this->m_a *= 2;
		return this;
	}

	//当然了C++中我们有引用不需要返回指针
	A& m_bAdd()
	{
		this->m_b *= 2;
		return *this;	//对this指针解引用取到的就是对象本身
	}

private:
	int m_a;
	int m_b;
	int m_c;
};

int main()
{
	A a;
	//对象a的地址和 aShow输出的地址是一样的
	cout << &a << endl;
	a.aShow();
	cout << endl;

	//因为返回的是自身对象的指针 所以可以一直使用成员运算符来调用
	a.m_aAdd()->m_aAdd()->m_aAdd()->aShow();
	cout << endl;

	//因为返回的是自身对象 所以可以一直使用成员运算符来调用
	a.m_bAdd().m_bAdd().m_bAdd().aShow();

	return 0;
}

 赋值运算符重载(赋值构造函数,这个说法有没有我也忘记了,反正我是一直这么叫的)

一个已有对象为另一个已有对象赋值的时候调用

如果不写,系统会自动生成一个浅拷贝的赋值构造函数

声明方式固定

        返回类引用 operator=(const 类引用)

系统自动生成的赋值构造函数不只是会对一段空间释放两次,还会造成内存泄漏.因为是两个已有对象间的赋值行为,被赋值的一方内存没有释放会直接改变指针指向新的空间,造成内存泄漏.

完整类(有参,无参,拷贝,赋值,析构)

#define _CRT_SECURE_NO_WARNINGS

#include <iostream>

using namespace std;

class Student
{
public:

	//无参构造函数
	Student()
	{
		this->m_name = new char[1];
		*this->m_name = 0;
	}

	//有参构造函数
	Student(const char* name)
	{
		m_name = new char[strlen(name) + 1];
		strcpy(m_name, name);
	}

	//拷贝构造函数
	Student(const Student& s)
	{
		m_name = new char[strlen(s.m_name) + 1];
		strcpy(m_name, s.m_name);
	}

	//赋值运算符重载(反正我一直叫它赋值构造函数)
	Student& operator=(const Student& s)
	{
		//因为需要释放原空间,如果不做此判断,会赋值释放的空间(值不确定)
		if (m_name == s.m_name)
		{
			return *this;
		}

		if (this->m_name != nullptr)
		{
			delete[]this->m_name;
			this->m_name = nullptr;
		}

		this->m_name = new char[strlen(s.m_name) + 1];
		strcpy(this->m_name, s.m_name);

		return *this;
	}

	//析构函数
	~Student()
	{
		if (this->m_name != nullptr)
		{
			delete[]this->m_name;
			this->m_name = nullptr;
		}
	}

	void studentShow()
	{
		cout << this->m_name << endl;
	}

private:
	char* m_name;
};

int main()
{
	//调用有参构造
	Student s = "hello world";

	//调用无参构造函数
	Student s2;

	//调用复制构造函数
	Student s3(s2);

	//调用赋值构造函数
	s2 = s3 = s;

	s.studentShow();
	s2.studentShow();
	s3.studentShow();

	return 0;
}