移动拷贝构造函数和移动赋值

my_string(const char* str)
{
int len = strlen(str);
len_ = len;
buffer_ = new char[len_ + 1];
memset(buffer_, 0, len_ + 1);
memcpy(buffer_, str, len_);
}

~my_string()
{
if (buffer_ != nullptr){
delete[]buffer_;
buffer_ = nullptr;
}
}

my_string()
{
buffer_ = new char[len_];
buffer_[0] = 0;
}

//默认的构造函数浅拷贝(不用delete的原因是object ob(ob1);一定分配好)
my_string(const my_string& str)
{
len_ = str.get_len();
if (len_ ==0){
return;
}
//语法没错，可能编译会抛
buffer_ = new char[len_ + 1];
memset(buffer_, 0, len_ + 1);
memcpy(buffer_, str.data(), len_);
}
//赋值构造函数
my_string& operator=(const my_string& str)
{
if (this !=&str){
int len = str.get_len();
if (this->buffer_ != nullptr) {
delete[] buffer_;
buffer_ = nullptr;
}

    len_ = len;
    this->buffer_ = new char[len_ + 1];
    memset(buffer_, 0, len_ + 1);
    memcpy(buffer_, str.data(), len_);
}
return *this;

}

my_string( my_string&& str) noexcept
{
this->buffer_ = str.data();
this->len_ = str.get_len();
str.set_len(0);
str.ret_null();
}
my_string& operator=(my_string&& str)noexcept {
if (this != &str){
if (buffer_ != nullptr){
delete[] buffer_;
buffer_ = nullptr;
}

        buffer_ = str.data();
        len_ = str.get_len();
        str.ret_null();
        str.set_len(0);
    }

    return *this;
}

std::size_t get_len()const {
    return len_;
}

char* data() const{
    return buffer_;
}

void ret_null() {
    buffer_ = nullptr;
}
void set_len(int len) {
    len_ = len;
}

#include
#include <type_traits>
//const my_string getPerson()
//{
// my_string person(“person in func”);
// return std::move(person);
//}

//不能返回局部变量的引用
//const my_string& getPerson()
//{
// my_string person(“person in func”);
// return person;
//}

//所以临时对象一定要std::move
const my_string getPerson()
{
my_string person(“person in func”);
return std::move(person);
}

int main()
{
//std::vector<my_string> src{ “foo”, “bar”, “baz” };
//std::vector<my_string> dest(src.size());
move_backward会执行移动赋值函数
//std::move_backward(src.begin(),src.end(),dest.end());
std::string str = “1234567”;
std::string str1 = “7895624”;
my_string mystr(str.c_str());
my_string mystr2(str1.c_str());
临时对象
my_string mystr33(getPerson());
一定赋值
mystr2 = std::move(mystr);

//临时对象会执行移动构造函数
//my_string mystr44(std::move(my_string("123")));
//forward也会讲一个左值变右值
//my_string mystr55(std::forward<my_string>(my_string("22222")));
//注意不会执行，移动构造函数
//它是一个左值拷贝
//my_string mystr55(my_string("123"));
return 0;

}
总结：
1:std::move函数就是左值转右值（若右值的话，就不想转）
2:std::forward函数就是左值转右值,右值的话就不转
3: move_backward会执行移动赋值函数