问题描述：
class 在拷贝过程中可能调用 默认构造函数和拷贝构造函数
这样可能（由2次拷贝）导致空间资源浪费
解决方法：用 移动语义 来解决。
在此示例中，只需写一个 move 构造函数，这和 copy构造函数相似，
除了它接收的是一个右值（临时值）之外
代码展示：
main1.cpp 复现 2 次 copy过程
main2.cpp 使用 move 构造函数对照（把 copy构造函数注释掉）
// main1.cpp
#include <iostream>
#include <cstring>
class String{
public:
String( ) = default;
// 默认构造函数
String( const char* string ){
std::cout << "Created! " << std::endl;
m_Size = strlen( string );
m_Data = new char[m_Size];
memcpy( m_Data, string, m_Size );
}
// copy 构造函数
String( const String& other ){
std::cout << "Copy! " << std::endl;
m_Size = other.m_Size;
m_Data = new char[m_Size];
memcpy( m_Data, other.m_Data, m_Size );
}
// 析构函数
~String( ){
std::cout << "Destroyed!" << std::endl;
delete[] m_Data;
}
void Print_String( ){
for( uint32_t i = 0; i < m_Size; i ++ ){
std::cout << m_Data[i];
}
std::cout << std::endl;
}
private:
char* m_Data;
uint32_t m_Size;
};
class Entity{
public:
Entity( const String& name ) : m_Name( name ) {}
void Print_Entity( ){
m_Name.Print_String();
}
private:
String m_Name;
};
int main( ){
/**
\* 解释：
\* 这里会首先 构造 class String，
\* 然后调用copy构造函数 给 class Entity
\* 函数输出：
\* Created!
\* Copy!
\* Destroyed!
\* Jeffy_Gao
\* Destroyed!
*/
std::cout << "test main1.cpp" << std::endl;
Entity entity( "Jeffy_Gao" );
entity.Print_Entity();
return 0;
}
问题描述：
class 在拷贝过程中可能调用 默认构造函数和拷贝构造函数
这样可能（由2次拷贝）导致空间资源浪费
解决方法：用 移动语义 来解决。
在此示例中，只需写一个 move 构造函数，这和 copy构造函数相似，
除了它接收的是一个右值（临时值）之外。
可以看到，实际只开辟了一块内存空间（而不是2块）
代码展示：
main1.cpp 复现 2 次 copy过程
main2.cpp 使用 move 构造函数对照（把 copy构造函数注释掉）
// main2.cpp
#include <iostream>
#include <cstring>
class String{
public:
String( ) = default;
// 默认构造函数
String( const char* string ){
std::cout << "Created! " << std::endl;
m_Size = strlen( string );
m_Data = new char[m_Size];
memcpy( m_Data, string, m_Size );
}
// copy 构造函数
String( const String& other ){
std::cout << "Copy! " << std::endl;
m_Size = other.m_Size;
m_Data = new char[m_Size];
memcpy( m_Data, other.m_Data, m_Size );
}
// move 构造函数
// 通过指定 move 构造函数，希望在执行“复制”时，不会复制内存，而是变成移动
// 当没有 move ctor时系统会调用 copy ctor； 有时，则调用 move ctor
// noexcept 运算符进行编译时检查，若表达式声明为不抛出任何异常则返回true。
String( String&& other ) noexcept{
std::cout << "Move! " << std::endl;
// 在这里直接复制数据，而不是分配新的内存缓冲区
// 现在这两个指针其实指向 同一块内存区了
m_Size = other.m_Size;
m_Data = other.m_Data;
/**在这里的时候引出一个问题：
\* 因为我们此刻仍然有 2 个字符串实例（m_Data, other.m_Data），当旧的
\* 被删除之后会发生什么？ => 它会把数据带走
\* 我们控制了 other.m_Data，偷走了 other.m_Data的数据
\* 因此：还需要处理另一个字符串：
*/
other.m_Size = 0;
other.m_Data = nullptr;
/**
\* 这样就只是接管了旧字符串(other.m_Data)，而不是通过复制它所有的数据和
\* 分配新的内存来进行深拷贝。（这里相当于做了一个浅拷贝）
*/
}
// 析构函数
~String( ){
std::cout << "Destroyed!" << std::endl;
/**
\* 当旧字符串实例被销毁后， delete m_Data会删除 other.m_Data 的nullptr
\*
*/
delete m_Data;
}
void Print_String( ){
for( uint32_t i = 0; i < m_Size; i ++ ){
std::cout << m_Data[i];
}
std::cout << std::endl;
}
private:
char* m_Data;
uint32_t m_Size;
};
class Entity{
public:
Entity( const String& name ) : m_Name( name ) {}
/** 这里做了相应更改，让其能够接收右值。下面两个写法一样
\* Entity( String&& name ) : m_Name( (String&&)name ) {}
\* 另外，剖析：
\* name在传参的时候已经声明了 String &&，右值，为什么函数体内还要 std::move(name)?
\* => 右值引用在进入函数体内后会变成左值。用专业的说法叫 "引用折叠"
\* 示例：
\* int &&rr1 = 42; // 正确
\* int &&rr2 = rr1; // 错误
\* int &&rr3 = std::move(rr1); // 正确
\*
\* 具体解释：
\* 因为右值引用在进入函数体内的之后, 参数类型会变为左值
\* 也就是在函数体内你可以对 String&& name中的 name取 &
\* 所以要触发移动语义必须让他变为右值引用, std::move 就是干这个转换的
\* 你看std::move的代码 就是干了一个找到源参数类型的static_cast转换
\* 把参数换成了 &&类 型。所以就能触发后面的移动构造函数
*/
Entity( String&& name ) : m_Name( std::move(name) ) {}
void Print_Entity( ){
m_Name.Print_String();
}
private:
String m_Name;
};
int main( ){
/**
\* 解释：
\* 这里会首先 构造 class String，
\* 然后调用copy构造函数 给 class Entity
\* 函数输出：
\* Created! "Jeffy_Gao" 被实例
\* Move! "Jeffy_Gao"传入 Entity，这时候不需要重新开辟堆上的空间
\* Destroyed! "Jeffy_Gao" 被析构
\* Jeffy_Gao entity.Print_Entity()
\* // 程序结束后还有一个 Destroyed， 是 Entity里的 m_Name 的析构
*/
std::cout << "test main2.cpp" << std::endl;
Entity entity( "Jeffy_Gao" );
entity.Print_Entity();
return 0;
}
