01 賦值運算子多載的需求
有時候希望賦值運算子兩邊的型別可以不匹配，比如：把一個 int 型別變數賦值給一個Complex（復數）物件，或把一個 char* 型別的字串賦值給一個字串物件，此時就需要多載賦值運算子‘=’，
需要注意的是：賦值運算子 = 只能多載為成員函式，
02 賦值運算子多載的例子
下面我們以自定義一個自己的字串類代碼的例子，講解賦值運算子的多載函式，
class MyString // 字串類
{
public:
// 建構式，默認初始化1個位元組的字符
MyString ():m_str(new char[1])
{
m_str[0] = 0;
}
// 解構式，釋放資源
~MyString()
{
delete [] m_str;
}
const char* c_str()
{
return m_str;
}
// 賦值運算子多載函式
// 多載=號使得 obj = "Hello" 能夠成立
MyString & operator= (const char *s)
{
// 釋放舊字串資源
delete [] m_str;
// 生成新字串的空間大小，長度多+1的目的是存放\0
m_str = new char[strlen(s) +1 ];
// 拷貝新字串的內容
strcpy(m_str, s);
// 回傳該物件
return *this;
}
private:
char * m_str; // 字串指標
};
int main() {
MyString s;
s = "Hello~"; // 等價于s.operator=("Hello~");
std::cout << s.c_str() << std::endl;
// MyString s2 = "Hello!"; // 這條陳述句要是不注釋就會編譯報錯
s = "Hi~"; // 等價于s.operator=("Hi~");
std::cout << s.c_str() << std::endl;
return 0;
}
輸出結果：
Hello~
Hi~
多載=號運算子函式后，s = "Hello~"; 陳述句就等價于 s.operator=("Hello~");，
需要注意的一點是：上面的MyString s2 = "Hello!";陳述句實際上是初始化陳述句，而不是賦值陳述句，因為是初始化陳述句，所以需要呼叫建構式進行初始化，那么這時就需要有char*引數的建構式，由于我們沒有定義此建構式，所以就會編譯出錯，
03 淺拷貝和深拷貝
還是依據上面的例子，假設我們要實作最后一個陳述句的方式：
MyString s1,s2;
s1 = "this"; // 呼叫多載的賦值陳述句
s2 = "that"; // 呼叫多載的賦值陳述句
s1 = s2; // 如何實作這個？？
s1 = s2;陳述句目的希望是s1物件放的字串和s2物件放的字串象要一樣，由于 = 號兩邊的類似都是物件，編譯器會用原生的賦值運算子函式，但是這個原生的賦值運算子函式對于有指標成員變數的物件來說，是非常危險的！
淺拷貝
如果用原生的賦值運算子函式去賦值有指標成員變數的物件，就會使得兩個物件的指標地址也是一樣的，也就是兩個物件的指標成員變數指向的地址是同一個地方，這種方式就是淺拷貝，
這時當一個物件釋放了指標成員變數時，那么另外一個物件的指標成員變數指向的地址就是空的了，再次使用這個物件時，程式就會奔潰了，因為該物件的指標成員函式已經是個不合法的指標了！
深拷貝
如果物件里面有指標成員變數，則我們需要對原生的賦值運算子函式，防止出現程式出錯現象的發生，
因此要在 class MyString 類里加上如下成員函式：
MyString & operator=(const MyString & s)
{
// 釋放舊字串資源
delete [] m_str;
// 生成新字串的空間大小，長度多+1的目的是存放\0
m_str = new char[strlen(s.m_str) +1 ];
// 拷貝新字串的內容
strcpy(m_str, s.m_str);
// 回傳該物件
return *this;
}
這么做就夠了嗎？還有什么需要改進的地方嗎？
我們在考慮下面的陳述句：
MyString s;
s = "Hello";
s = s; // 是否會有問題？
最后一個陳述句是否會有問題？
s = s;等價于s.operator=(s)，由于s和s是相同的物件，那么就沒必要完全執行多載的賦值 = 的函式了，我們再加個判斷，當左右兩邊是相同物件時，就直接回傳該物件就好：
MyString & operator=(const MyString & s)
{
// 當左右兩邊是相同物件時，就直接回傳該物件就
if(this == &s)
return *this;
delete [] m_str;
m_str = new char[strlen(s.m_str) +1 ];
strcpy(m_str, s.m_str);
return *this;
}
對operator=回傳值型別的討論
- void 好不好？
- MyString 好不好？
- 為什么是MyString &？
當我們多載一個運算子的時候，好的風格應該是盡量保留運算子原本的特性
考慮：
a = b = c;這個賦值陳述句的順序是先b = c，然后在a = (b = c)，如果回傳的void型別，那么a = (void)顯然是不成立的；(a = b) = c;這個賦值陳述句會修改a的值，如果回傳的型別是MyString物件，那么就無法修改a的值了，
分別等價于：
a.operator=(b.operator=(c));(a.operator=(b)).operator=(c);
所以綜上考慮，operator=回傳值型別是MyString &是比較好的，
04 復制（拷貝）建構式
上面的MyString類是否就沒有問題了？
MyString s;
s = "Hello";
MyString s1(s); // 要考慮這種情況，那就要多載復制（拷貝）建構式
如果使用默認的復制（拷貝）建構式，那就對有指標成員變數的物件會有問題，因為會默認的復制（拷貝）建構式會導致兩個物件的指標成員變數指向同一個的空間，
所以需要對復制（拷貝）建構式多載，并實作深拷貝的方式：
MyString (const MyString &s)
{
m_str = new char[strlen(s.m_str) + 1];
strcpy(m_str, s.m_str);
}
05 小結
最后的所有代碼，如下：
class MyString // 字串類
{
public:
// 建構式，默認初始化1個位元組的字符
MyString ():m_str(new char[1])
{
m_str[0] = 0;
}
// 復制（拷貝）建構式
MyString (const MyString &s)
{
m_str = new char[strlen(s.m_str) + 1];
strcpy(m_str, s.m_str);
}
// 解構式，釋放資源
~MyString()
{
delete [] m_str;
}
const char* c_str()
{
return m_str;
}
// 賦值運算子多載函式
// 多載=號使得 obj = "Hello" 能夠成立
MyString & operator= (const char *s)
{
// 釋放舊字串資源
delete [] m_str;
// 生成新字串的空間大小，長度多+1的目的是存放\0
m_str = new char[strlen(s) +1 ];
// 拷貝新字串的內容
strcpy(m_str, s);
// 回傳該物件
return *this;
}
// 賦值運算子多載函式
// 多載=號使得 obj1 = obj2 能夠成立
MyString & operator=(const MyString & s)
{
// 當左右兩邊是相同物件時，就直接回傳該物件就
if(this == &s)
return *this;
delete [] m_str;
m_str = new char[strlen(s.m_str) +1 ];
strcpy(m_str, s.m_str);
return *this;
}
private:
char * m_str; // 字串指標
};
int main()
{
MyString s1,s2;
s1 = "Hello~"; // 等價于s1.operator=("Hello~");
std::cout << s1.c_str() << std::endl;
s2 = "Hi~"; // 等價于s2.operator=("Hi~");
std::cout << s2.c_str() << std::endl;
s1 = s2; // 等價于s1.operator=(s2);
std::cout << s1.c_str() << std::endl;
MyString s3(s1); // 復制建構式
std::cout << s3.c_str() << std::endl;
return 0;
}
輸出如下：
Hello~
Hi~
Hi~
Hi~
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/83158.html
標籤：C++
上一篇：C++ 運算子多載的基本概念