有指针或者多维数组时，如何写拷贝构造函数，移动构造函数，拷贝赋值运算符，移动赋值运算符

蜉蝣之翼❉

已于 2023-08-31 18:01:25 修改

阅读量512

点赞数

分类专栏： C++ 文章标签： c++

于 2023-08-31 17:57:07 首次发布

本文链接：https://blog.csdn.net/fuyouzhiyi/article/details/132608171

版权

C++ 专栏收录该内容

50 篇文章 3 订阅

订阅专栏

当成员变量里面有指针或者多维数组时，如何写拷贝构造函数，移动构造函数，拷贝赋值运算符，移动赋值运算符

头文件

#pragma once
#include<iostream>
using namespace std;
const int num = 5;
/*
重写C++默认函数
*/
class DefaultRewrite
{
public:
	DefaultRewrite();
	// 拷贝构造函数
	DefaultRewrite(const DefaultRewrite& other);
	// 手动定义拷贝赋值运算符
	DefaultRewrite& operator=(const DefaultRewrite& other);
	// 移动构造函数
	DefaultRewrite(DefaultRewrite&& other);
	// 自定义移动赋值运算符
	DefaultRewrite& operator=(DefaultRewrite&& other);
	void initBuffer(char* copy,int size);
	void printDefaultRewrite();
private:

	char* m_pBuf;
	int cal[num][num];
	int m_bufSize;
};

实现

#include "DefaultRewrite.h"


DefaultRewrite::DefaultRewrite():
	m_pBuf(nullptr), cal{}, m_bufSize(num)
{
	cout << "默认构造函数" << endl;
}

DefaultRewrite::~DefaultRewrite()
{
	if (m_pBuf  )
	{
		delete[] m_pBuf;
	}
	m_pBuf = nullptr;
	cout << "析构函数" << endl;
}
void DefaultRewrite::initBuffer(char* copy, int size)
{
	int minsize = min(size, m_bufSize);
	if (m_pBuf == nullptr)
	{
		m_pBuf = new char[m_bufSize];
	}
	//std::copy(copy, copy + minsize, m_pBuf);
	memcpy(m_pBuf, copy, m_bufSize);
	for (int i = 0; i < num; i++) 
	{
		for (int j = 0; j < num; j++) 
		{
			cal[i][j] = i+j;
		}
	}
}

// 拷贝构造函数
DefaultRewrite::DefaultRewrite(const DefaultRewrite& other)
	: m_pBuf(other.m_pBuf) , m_bufSize(other.m_bufSize)
{
	cout << "拷贝构造函数" << endl;
	std::copy(&other.cal[0][0], &other.cal[0][0] + num * num, &cal[0][0]);
	if (other.m_pBuf)
	{
		m_pBuf = new char[m_bufSize];

		//std::copy(other.m_pBuf, other.m_pBuf + m_bufSize, m_pBuf);
		memcpy(m_pBuf, other.m_pBuf, m_bufSize);
	}
	else
	{
		m_pBuf = nullptr;
	}

}

// 拷贝赋值运算符
DefaultRewrite& DefaultRewrite::operator=(const DefaultRewrite& other) {
	cout << "拷贝赋值运算符" << endl;
	
	if (this == &other) return *this;

	if (m_pBuf)
	{
		delete[] m_pBuf;
	}
	// 深拷贝
	m_pBuf = new char[m_bufSize];
	std::copy(&other.cal[0][0], &other.cal[0][0] + num * num, &cal[0][0]);
	//std::copy(other.m_pBuf, other.m_pBuf + m_bufSize, m_pBuf);
	memcpy(m_pBuf, other.m_pBuf, m_bufSize);
	return *this;
}

// 移动构造函数
DefaultRewrite::DefaultRewrite(DefaultRewrite&& other) 
	: m_pBuf(other.m_pBuf), m_bufSize(other.m_bufSize)
{
	
	cout << "移动构造函数" << endl;
	other.m_pBuf = nullptr;
	std::copy(&other.cal[0][0], &other.cal[0][0] + num * num, &cal[0][0]);
}

// 移动赋值运算符
DefaultRewrite& DefaultRewrite::operator=(DefaultRewrite&& other) 
{
	
	cout << "移动赋值运算符" << endl;
	if (this == &other) return *this;

	if (m_pBuf)
	{
		delete[] m_pBuf;
	}

	m_pBuf = other.m_pBuf;
	m_bufSize = other.m_bufSize;
	std::copy(&other.cal[0][0], &other.cal[0][0] + num * num, &cal[0][0]);

	other.m_pBuf = nullptr;

	return *this;
}

void DefaultRewrite::printDefaultRewrite()
{
	if(m_pBuf)
	cout << m_pBuf << endl;
	for (int i = 0; i < num; i++)
	{
		for (int j = 0; j < num; j++)
		{
			cout << cal[i][j] << "  ";
		}
		cout << endl;
	}
}

main

int main()
{	DefaultRewrite obj1; // 默认构造函数
	cout << "obj1" << endl;
	obj1.printDefaultRewrite();

	char str[] = "hi";
	obj1.initBuffer(str,3);
	cout << "obj1 initBuffer" << endl;
	obj1.printDefaultRewrite();

	DefaultRewrite obj2 = obj1; // 拷贝构造函数
	cout << "obj2" << endl;
	obj2.printDefaultRewrite();
	

	DefaultRewrite obj3;
	obj3 = obj1; // 拷贝赋值运算符
	cout << "obj3" << endl;
	obj3.printDefaultRewrite();

	DefaultRewrite obj4(std::move(obj2)); // 移动构造函数
	cout << "obj4" << endl;
	obj4.printDefaultRewrite();

	DefaultRewrite obj5;
	obj5 = std::move(obj1); // 移动赋值运算符
	cout << "obj5" << endl;
	obj5.printDefaultRewrite();


	cout << "obj1" << endl;
	obj1.printDefaultRewrite();

	cout << "obj2" << endl;
	obj2.printDefaultRewrite();
}