- 本节介绍拷贝构造函数。
- 当我们复制数据或对象是一般情况下我们会有两个副本。但当我们仅需要读取数据或者修改一个已经存在的对象时，我们不想去复制一份副本，这样会造成性能的损耗。理解什么时候复制，什么时候不需要复制对提升程序的性能有较大的帮助。
- 接下来的示例展示复制操作以及不想复制的时候需要怎样去操作。
cpp
#include <iostream>
#include <string>
#include <memory>
class Entity
{
public:
int x, y;
Entity(int x, int y)
{
this->x = x;
this->y = y;
std::cout << "这是构造函数！！！" << std::endl;
}
~Entity()
{
std::cout << "这是析构函数！！！" << std::endl;
}
};
int main()
{
//Entity e1(2,5);
//Entity e2 = e1;
//e2.x = 9; //此时修改e2中属性变量的值不会影响e1,因为我们复制了一根Entity
Entity *e1 = new Entity(2, 5);
Entity* e2 = e1;
e2->x = 4; //此时修改e2中属性变量的值会影响e1,因为我们复制了e1的地址到e2，它两指向同样的地址
std::cin.get();
return 0;
}-
手动实现String类来展示copy操作
cpp
#include <iostream>
#include <string>
#include <memory>
//自己实现string来更好的展示拷贝复制构造函数
class String
{
private:
char* m_Buffer;
unsigned int m_Size;
public:
String(const char* string)
{
m_Size = strlen(string);
m_Buffer = new char[m_Size+1]; //+1是因为要添加一个空终止符
memcpy(m_Buffer, string, m_Size);
m_Buffer[m_Size] = 0;
}
~String()
{
delete[] m_Buffer;
}
friend std::ostream& operator<<(std::ostream& stream, const String& string);
};
std::ostream& operator<<(std::ostream& stream, const String& string)
{
stream << string.m_Buffer;
return stream;
}
int main()
{
String s1 = "pcop";
/*
下面这种方式进行copy操作会导致程序崩溃，因为在此处=操作进行的是浅拷贝，
会导致两个String对象中的m_Buffer指向同一块内存地址，这样就会导致析构函数
会对同一块内存地址释放两次
*/
String s2 = s1;
std::cin.get();
return 0;
}
cpp
#include <iostream>
#include <string>
#include <memory>
//自己实现string来更好的展示拷贝复制构造函数
class String
{
private:
char* m_Buffer;
unsigned int m_Size;
public:
String(const char* string)
{
m_Size = strlen(string);
m_Buffer = new char[m_Size+1]; //+1是因为要添加一个空终止符
memcpy(m_Buffer, string, m_Size);
m_Buffer[m_Size] = 0;
}
//拷贝构造函数
String(const String& other)
:m_Size(other.m_Size)
{
m_Buffer = new char[m_Size+1];
memcpy(m_Buffer, other.m_Buffer, m_Size+1);
}
char& operator[] (int index)
{
return m_Buffer[index];
}
~String()
{
delete[] m_Buffer;
}
friend std::ostream& operator<<(std::ostream& stream, const String& string);
};
std::ostream& operator<<(std::ostream& stream, const String& string)
{
stream << string.m_Buffer;
return stream;
}
int main()
{
String s1 = "pcop";
/*
* 如果不是先上诉的拷贝构造函数
下面这种方式进行copy操作会导致程序崩溃，因为在此处=操作进行的是浅拷贝，
会导致两个String对象中的m_Buffer指向同一块内存地址，这样就会导致析构函数
会对同一块内存地址释放两次
*/
String s2 = s1;
/*
* 下面操作修改s2的时候s1的值也会修改，因为两个String对象的m_Buffer指向同一块内存
* 我们在复制中应该的操作是分配一块新的内存用来复制m_Buffer
*/
s2[2] = 'z';
//解决上诉方法可以通过深拷贝来完成，本示例中通过拷贝构造函数来实现
std::cout << s1 << std::endl;
std::cout << s2 << std::endl;
std::cin.get();
return 0;
}
cpp
#include <iostream>
#include <string>
#include <memory>
//自己实现string来更好的展示拷贝复制构造函数
class String
{
private:
char* m_Buffer;
unsigned int m_Size;
public:
String(const char* string)
{
m_Size = strlen(string);
m_Buffer = new char[m_Size+1]; //+1是因为要添加一个空终止符
memcpy(m_Buffer, string, m_Size);
m_Buffer[m_Size] = 0;
}
//拷贝构造函数
String(const String& other)
:m_Size(other.m_Size)
{
std::cout << "Copy String!!!" << std::endl;
m_Buffer = new char[m_Size+1];
memcpy(m_Buffer, other.m_Buffer, m_Size+1);
}
char& operator[] (int index)
{
return m_Buffer[index];
}
~String()
{
delete[] m_Buffer;
}
friend std::ostream& operator<<(std::ostream& stream, const String& string);
};
std::ostream& operator<<(std::ostream& stream, const String& string)
{
stream << string.m_Buffer;
return stream;
}
void PringString(const String& s)
{
std::cout << s << std::endl;
}
int main()
{
String s1 = "pcop";
/*
* 如果不是先上诉的拷贝构造函数
下面这种方式进行copy操作会导致程序崩溃，因为在此处=操作进行的是浅拷贝，
会导致两个String对象中的m_Buffer指向同一块内存地址，这样就会导致析构函数
会对同一块内存地址释放两次
*/
String s2 = s1;
/*
* 下面操作修改s2的时候s1的值也会修改，因为两个String对象的m_Buffer指向同一块内存
* 我们在复制中应该的操作是分配一块新的内存用来复制m_Buffer
*/
s2[2] = 'z';
//解决上诉方法可以通过深拷贝来完成，本示例中通过拷贝构造函数来实现
/*
* 如果 PringString(String& s)
以下PringString方法调用的时候都会调用String的拷贝构造函数，每次需要分配新的内存
会造成很大的性能浪费，我们只是想直接打印PringString方法的参数，不想通过复制。
所以在PringString参数传递是直接传递引用 PringString(const String& s)
*/
PringString(s1);
PringString(s2);
std::cin.get();
return 0;
}