C++ 中的三大法則
三大法則是全球最流行的編碼習慣之一。法律規定 C++ 有一些必須一起宣告的特殊功能,即使是必需的。
這些函式是複製建構函式、複製賦值運算子和解構函式。
法律規定,如果在程式中宣告瞭三個特殊功能之一,則其他兩個也必須遵循。如果沒有,程式就會遇到嚴重的記憶體洩漏。
本文將詳細解釋三大法則以及如何繞過它。
瞭解 C++ 中的三大法則
必須考慮到當動態分配的資源被新增到一個類中時,會發生什麼情況,以瞭解大三大法則。
在下面的示例中,建立了一個建構函式類,它為指標分配一些記憶體空間。
class Big3 {
int* x;
public:
Big3() : x(new int()) {
std::cout << "Resource allocated \n";
}
};
如上所示,記憶體被分配給指標。現在,它也必須使用解構函式釋放。
~Big3() {
std::cout << "Resource is released \n";
delete x;
}
普遍的看法是,工作到此為止。但現實還很遙遠。
在此類中啟動複製建構函式時會發生一些嚴重的記憶體洩漏。
這個問題背後的原因是建構函式的隱式定義。當一個物件在沒有定義建構函式的情況下被複制時,編譯器會隱式建立一個複製建構函式,該建構函式不會建立克隆,而只是同一物件的影子。
預設情況下,複製建構函式對物件執行淺拷貝。程式使用這種複製方法執行良好,直到某些資源被動態分配給一個物件。
例如,在下面的程式碼中,建立了一個物件 p1
。另一個物件 p2
是 p1
的複製物件。
int main() {
Big3 p1;
Big3 p2(p1);
}
在這段程式碼中,當解構函式銷燬物件 p1
時,p2
成為一個懸空指標。這是因為物件 p2
指向物件 p1
的引用。
為了更好地理解,下面給出了完整的程式碼。
#include<iostream>
class Big3 {
int* x;
public:
Big3() : x(new int()) {
std::cout << "Resource allocated \n";
}
~Big3() {
std::cout << "Resource is released \n";
delete x;
}
};
int main() {
Big3 p1;
Big3 p2(p1);
}
為了避免像懸空指標這樣的問題,程式設計師需要顯式宣告所有必需的建構函式,這就是三大規則的內容。
C++ 中建構函式的隱式定義
有兩種方法可以製作物件的副本。
- 淺拷貝——使用建構函式拷貝一個物件的地址,並將其儲存在新的物件中。
- 深度複製 - 使用類似的建構函式,將儲存在該地址內的值複製到新地址中。
通常,當為物件分配一些記憶體時,複製建構函式的隱式版本會複製指標 x
的引用,而不是建立具有自己的記憶體分配集的新物件。
下面是如何隱式定義特殊成員函式的表示。
book(const book& that) : name(that.name), slno(that.slno)
{
}
book& operator=(const book& that)
{
name = that.name;
slno = that.slno;
return *this;
}
~book()
{
}
在這個例子中,定義了三個特殊的成員函式。第一個是複製建構函式,它通過成員初始化器列表分配成員變數:name(that.name), slno(that.slno)
。
第二個建構函式是建立類物件副本的複製賦值建構函式。在這裡,運算子過載用於建立物件的副本。
最後,解構函式保持為空,因為沒有分配任何資源。該程式碼不會引發錯誤,因為物件不需要任何記憶體分配。
為什麼隱式定義在資源管理中失敗
假設類的成員指標接收記憶體分配。當使用預設賦值運算子和複製函式建構函式複製此類的物件時,此成員指標的引用將被複制到新物件。
結果,對一個物件所做的任何更改也會影響另一個物件,因為新物件和舊物件都將指向相同的記憶體位置。第二個物件將繼續嘗試使用它。
class person
{
char* name;
int age;
public:
// constructor acquires a resource
// dynamic memory obtained via new
person(const char* the_name, int the_age)
{
name = new char[strlen(the_name) + 1];
strcpy(name, the_name);
age = the_age;
}
// destructor must release this resource via delete
~person()
{
delete[] name;
}
};
上面的例子複製了 name
,它複製了指標,將值儲存在裡面。
宣告解構函式時,它只是刪除原始物件的例項。但是複製的物件一直指向同一個引用,現在該引用已被破壞。
這是記憶體洩漏的主要原因。它們出現在解構函式刪除原始物件及其引用時,而複製建構函式建立的物件繼續懸空,也稱為懸空指標。
類似地,如果懸空指標未選中,那麼該記憶體引用將在未來造成多個記憶體洩漏。
這個問題的唯一解決方案是顯式宣告建構函式,或者簡單地說,建立自己的複製建構函式和賦值運算子模型來解決這個問題。
自定義建構函式複製初始指標指向的值而不是其地址,為新物件分配單獨的記憶體。
C++ 中建構函式的顯式定義
據觀察,隱式定義的建構函式導致物件的淺拷貝。為了解決這個問題,程式設計師明確定義了一個複製建構函式,它有助於在 C++ 中深度複製物件。
深度複製是一種分配新記憶體塊來儲存指標值的方法,而不僅僅是儲存記憶體引用。
此方法需要顯式定義所有三個特殊成員方法,以便編譯器在複製物件時分配新記憶體。
解構函式在 C++ 中顯式定義的建構函式中的作用
必須建立解構函式來擦除分配給函式物件的記憶體。如果你不這樣做,這可能會導致記憶體洩漏。
在隱式建構函式中,即使宣告瞭解構函式,問題仍然存在。出現問題是因為如果複製分配的物件記憶體,則複製的物件將指向與原始物件相同的記憶體。
當一個刪除其解構函式中的記憶體時,另一個將有一個指向無效記憶體的指標,當它嘗試使用它時事情會變得複雜。
因此,必須建立顯式定義的複製建構函式,為新物件提供要清除的記憶體碎片。
下面的程式顯示了一個遵守三大法則的演示類。
class name{
private:
int* variable; //pointer variable
public:
// Constructor
name()
{
variable = new int;
}
void input(int var1) // Parameterized method to take input
{
*variable = var1;
}
//Copy Constructor
name(name& sample)
{
variable = new int;
*variable = *(sample.variable);
//destructor
~name()
{
delete variable;
}
};
在 C++ 中實現複製建構函式
該程式有一個類 Book
,它帶有一個預設的引數化建構函式和一個解構函式。當沒有提供輸入時,預設建構函式返回空值,而引數化建構函式初始化這些值並複製它們。
這裡包含了一個異常處理方法(try-catch
),當變數 m_Name
無法分配資源時,它會丟擲異常。
在解構函式之後,會建立一個複製建構函式,用於複製原始物件。
#include <iostream>
#include <exception>
#include <cstring>
using namespace std;
class Book {
int m_Slno;
char* m_Name;
public:
// Default Constructor
Book() :
m_Slno(0),
m_Name(nullptr)
{
}
// Parametarized Constructor
Book(int slNumber, char* name) {
m_Slno = slNumber;
unsigned int len = strlen(name) + 1;
try {
m_Name = new char[len];
} catch (std::bad_alloc e) {
cout << "Exception received: " << e.what() << endl;
return;
}
memset(m_Name, 0, len);
strcpy(m_Name, name);
}
// Destructor
~Book() {
if(m_Name) {
delete [] m_Name;
m_Name = nullptr;
}
}
friend ostream& operator<<(ostream& os, const Book& s);
};
ostream& operator<<(ostream& os, const Book& s) {
os << s.m_Slno << ", " << s.m_Name << endl;
return os;
}
int main() {
Book s1(124546, "Digital Marketing 101");
Book s2(134645, "Fault in our stars");
s2 = s1;
cout << s1;
cout << s2;
s1.~Book();
cout << s2;
return 0;
}
在主函式中,當物件 s1
被銷燬時,s2
不會丟失它的動態物件,即物件 s
的字串變數。
下面的另一個示例演示瞭如何使用複製建構函式深度複製物件。在下面的程式碼中,建立了一個建構函式類 design
。
該類具有三個私有變數——靜態 l
和 h
中的兩個,以及一個動態物件 w
。
#include <iostream>
using namespace std;
// A class design
class design {
private:
int l;
int* w;
int h;
public:
// Constructor
design()
{
w = new int;
}
// Method to take input
void set_dimension(int len, int brea,
int heig)
{
l = len;
*w = brea;
h = heig;
}
// Display Function
void show_data()
{
cout << "The Length is = " << l << "\n"
<< "Breadth of the design = " << *w << "\n"
<< "Height = " << h << "\n"
<< endl;
}
// Deep copy is initialized here
design(design& sample)
{
l = sample.l;
w = new int;
*w = *(sample.w);
h = sample.h;
}
// Destructor
~design()
{
delete w;
}
};
// Driver Code
int main()
{
// Object of class first
design first;
// Passing Parameters
first.set_dimension(13, 19, 26);
// Calling display method
first.show_data();
// Copying the data of 'first' object to 'second'
design second = first;
// Calling display method again to show the 'second' object
second.show_data();
return 0;
}
輸出:
The Length is = 13
Breadth of the design = 19
Height = 26
The Length is = 13
Breadth of the design = 19
Height = 26
--------------------------------
Process exited after 0.2031 seconds with return value 0
Press any key to continue . . .
まとめ
本文全面而詳細地解釋了 big 3 規則以及它如何影響程式設計。讀者可以瞭解三大法則的必要性和重要性。
除此之外,還解釋了一些新概念,例如深拷貝和淺拷貝,它們有幾種實現方式。