重载赋值运算符

在一个类里面，编译器默认给我们添加了一个赋值运算符的重载，这样我们就能给两个对象之间进行赋值运算

class Role
{
public:int hp;int mp;
}
int main()
{Role x,y;x.hp=100;x.mp=200;y=x;std::cout<<y.hp<<y.mp;
}

像这样，就完成了两个对象之间的赋值

但是如果在代码中加上这么一行，就不能完成赋值

class Role
{
public:int hp;int mp;Role& operate=(const Role& role)=delete;
}
int main()
{Role x,y;x.hp=100;x.mp=200;y=x;std::cout<<y.hp<<y.mp;
}

以上的代码是不能运行的，因为删除了默认的重载赋值的函数

特别注意*：类的赋值重载只能是成员函数，不能是全局函数

我们自己重载一下

class Role
{
public:int hp;int mp;Role& operator= (const Role& role);
};
Role& Role::operator= (const Role& role)
{hp = role.hp;mp = role.mp+100;return *this;
}

这里的返回值为什么要写成Role&呢？因为如果我们要实现x=y=z，就要把它的返回值写成Role类型，用引用更加省内存。

既然，我们有了默认的赋值重载，为什么还要自己实现一个赋值重载呢，那是因为默认的赋值重载不能解决浅拷贝带来的问题

class hstring
{
private:char* cstr;
public:hstring(const char* _str){cstr = (char*)_str;}char* getstr(){return cstr;}
};
int main()
{char str[]{ "1234567890aaaaa" };hstring hstr(str);    str[0] = 0 ;std::cout << hstr.getstr();system("pause");
}

这里，最后居然无法输出，当我们改变str的值后，hstr居然有跟着改变，是因为它们共享一个内存

下面，我们写一个如何重载=，并解决浅拷贝的问题

hstring.cpp的内容

#include"hstring.h"
hstring::hstring()
{cstr = nullptr;     //指针初始化usmlen = 0x32;      //给予usmlen一个初始值，不然进入copystr函数后，无法与len进行比较
}
unsigned short hstring::getlength(const char* str)
{unsigned short len{};for (; str[len]; len++);return len;
}
void hstring::copystr(char*& dest, const char* source)
{unsigned short len = getlength(source);if (len > usmlen){dest = new char[len + 1];   //重新分配内存usmlen = len;}dest = new char[0x32];memcpy(dest, source, usmlen);
}
hstring::hstring(const char* _str) :hstring()
{copystr(cstr, _str);
}
hstring::hstring(const hstring& hstr) : hstring()
{copystr(cstr, hstr.cstr);
}
hstring& hstring::operator=(const hstring& hstr)
{copystr(cstr, hstr.cstr);return *this;
}
//hstring& hstring::operator=(const char* str)
//{
//    cstr = nullptr;
//    usmlen = 0x32;
//    copystr(cstr, str);
//    return *this;
//}
hstring& hstring::operator=(const long long value)
{std::string str= std::to_string(value);const char* p = str.c_str();copystr(cstr, p);return *this;
}

为什么这里的 operator=(const char* str)不需要写呢？

主函数

#include<iostream>
#include"hstring.h"int main()
{char* c_str{ "1234552444" };char a_str[]{ "88888" };hstring hstr=c_str;    调用了hstring(const char* _str)                            hstring hstr1=hstr;    调用了hstring(const hstring& hstr)hstr1 = hstr;          调用了hstring::operator=(const hstring& hstr)hstr1 = a_str;         调用了hstring& hstring::operator=(const char* str)hstr1 = 999999;        调用了hstring& hstring::operator=(const long long value)std::cout << hstr.getstr() << std::endl;std::cout << hstr1.getstr() << std::endl;system("pause");
}

 hstring.h的内容

#pragma once
#include<iostream>
#include<string>
class hstring
{
private:unsigned short usmlen{};   //新建的内存长度char* cstr;             //字符串unsigned short getlength(const char* str);     //得到对象的字符串长度void copystr(char*& dest, const char* source);   //复制内存函数
public:hstring();hstring(const char* _str);hstring(const hstring& hstr);hstring& operator=(const hstring& str);hstring& hstring::operator=(const long long value);//hstring& operator= (const char* str);char* getstr(){return cstr;}
};