大疆C++一面：C++什么時候生成默認拷貝構造函數？
在 C++ 編程里，拷貝構造函數扮演著關鍵角色，它負責用一個已有的對象來初始化同類型的新對象。那 C++ 什么時候生成默認拷貝構造函數呢？這一問題對理解對象的創(chuàng)建與復制機制極為重要。當我們沒有顯式定義拷貝構造函數時，編譯器并非總會自動生成默認的拷貝構造函數，只有在特定情形下才會生成。比如說，若類包含一個類類型（非內置類型）的成員變量，且該成員變量所屬的類有拷貝構造函數，編譯器就會為當前類生成默認拷貝構造函數。舉個例子，有個 Student 類，它包含一個 Address 類類型的成員變量，如果 Address 類有拷貝構造函數，那么在沒有給 Student 類顯式定義拷貝構造函數時，編譯器就會為 Student 類生成默認拷貝構造函數。
另外，若類繼承自含有拷貝構造函數的基類，編譯器也會為該類生成默認拷貝構造函數。比如 GraduateStudent 類繼承自 Student 類，若 Student 類有拷貝構造函數，而 GraduateStudent 類未顯式定義拷貝構造函數，編譯器就會為 GraduateStudent 類生成默認拷貝構造函數 ，這樣在對 GraduateStudent 類對象進行拷貝初始化時，就能正確調用基類的拷貝構造函數來處理基類部分的數據成員。同時，當類繼承或聲明了虛函數，或者類含有虛基類時，編譯器同樣會生成默認拷貝構造函數。這是因為虛函數機制和虛基類的存在，使得對象在內存布局和多態(tài)行為上更為復雜，需要默認拷貝構造函數來確保對象在拷貝過程中，虛函數表指針等關鍵信息能夠正確復制，維持多態(tài)特性的正常運作。
一、拷貝構造函數是什么
在C++的世界里，拷貝構造函數是一種特殊的構造函數，它在對象的復制和初始化過程中扮演著舉足輕重的角色。其形參是本類對象的引用，作用是使用一個已經存在的對象去初始化一個新的同類對象 ，一般形式為類名(const 類名& 對象名) 。
舉個例子，假設有一個Student類：
class Student {
public:
std::string name;
int age;
// 拷貝構造函數
Student(const Student& other) : name(other.name), age(other.age) {
std::cout << "拷貝構造函數被調用" << std::endl;
}
};在上述代碼中，Student(const Student& other)就是Student類的拷貝構造函數。當我們使用一個已有的Student對象去初始化另一個新的Student對象時，這個拷貝構造函數就會被調用。比如：
int main() {
Student s1;
s1.name = "Alice";
s1.age = 20;
Student s2 = s1; // 調用拷貝構造函數
return 0;
}在這段代碼中，Student s2 = s1;這一行代碼就會調用Student類的拷貝構造函數，將s1對象的name和age成員變量的值復制給s2對象，從而完成s2對象的初始化 。
拷貝構造函數的調用場景主要有以下幾種：
①對象初始化時：當使用一個已創(chuàng)建的對象為新對象賦值時，會調用拷貝構造函數。如MyClass obj1; MyClass obj2 = obj1; ，這里obj2會被初始化為obj1的一個副本，即obj2的成員變量會被初始化為與obj1相同的值。
②函數參數傳遞時：如果函數的形參是類的對象，并且是以值傳遞的方式傳遞參數，那么在調用函數時會調用拷貝構造函數來創(chuàng)建形參對象的副本。例如：
void myFunction(MyClass obj) {
// 函數體
}當調用myFunction函數并傳遞一個MyClass類型的對象作為參數時，會調用該對象的拷貝構造函數來創(chuàng)建函數參數obj的副本。這樣，在函數內部對obj的操作不會影響到原始的對象。
③函數返回值時：當函數的返回值是類的對象，并且是以值傳遞的方式返回時，會在函數返回時調用拷貝構造函數來創(chuàng)建返回值的副本。例如：
MyClass myFunction() {
MyClass obj;
return obj;
}在myFunction函數中，當返回obj對象時，會調用obj的拷貝構造函數來創(chuàng)建一個臨時對象作為返回值。這個臨時對象會在調用者接收返回值時被復制到接收變量中。
二、什么時候調用拷貝構造函數
了解了拷貝構造函數的定義后，我們來看看它在哪些情況下會被調用。拷貝構造函數主要在以下三種常見場景中發(fā)揮作用：
2.1對象初始化時
當使用一個已有的對象來初始化另一個同類型的新對象時，拷貝構造函數會被調用。例如：
class Point {
public:
int x;
int y;
Point(int a, int b) : x(a), y(b) {}
Point(const Point& other) : x(other.x), y(other.y) {
std::cout << "拷貝構造函數在對象初始化時被調用" << std::endl;
}
};
int main() {
Point p1(1, 2);
Point p2 = p1; // 調用拷貝構造函數，用p1初始化p2
return 0;
}在上述代碼中，Point p2 = p1;這行代碼使用p1對象初始化p2對象 ，此時會調用Point類的拷貝構造函數，將p1的成員變量x和y的值復制給p2 。
2.2函數參數傳遞時
當函數的參數是類的對象，并且采用值傳遞的方式時，在函數調用時會調用拷貝構造函數，創(chuàng)建一個實參對象的副本傳遞給函數形參。例如：
class Rectangle {
public:
int width;
int height;
Rectangle(int w, int h) : width(w), height(h) {}
Rectangle(const Rectangle& other) : width(other.width), height(other.height) {
std::cout << "拷貝構造函數在函數參數傳遞時被調用" << std::endl;
}
};
void printRectangle(Rectangle rect) {
std::cout << "Width: " << rect.width << ", Height: " << rect.height << std::endl;
}
int main() {
Rectangle r1(10, 5);
printRectangle(r1); // 調用拷貝構造函數，將r1復制給形參rect
return 0;
}在這段代碼中，printRectangle函數的參數rect是通過值傳遞的方式接收Rectangle類型的對象。當調用printRectangle(r1)時，會調用Rectangle類的拷貝構造函數，創(chuàng)建一個r1的副本傳遞給rect 。這樣在函數內部對rect的操作不會影響到原始的r1對象 。
2.3函數返回值時
當函數返回一個類的對象，并且采用值返回的方式時，在函數返回時會調用拷貝構造函數，創(chuàng)建一個臨時對象作為返回值返回給調用者。例如：
class Circle {
public:
int radius;
Circle(int r) : radius(r) {}
Circle(const Circle& other) : radius(other.radius) {
std::cout << "拷貝構造函數在函數返回值時被調用" << std::endl;
}
};
Circle createCircle() {
Circle c(5);
return c; // 調用拷貝構造函數，創(chuàng)建臨時對象返回
}
int main() {
Circle myCircle = createCircle();
return 0;
}在createCircle函數中，返回Circle類型的對象c時，會調用Circle類的拷貝構造函數，創(chuàng)建一個臨時對象作為返回值。然后這個臨時對象會被賦值給main函數中的myCircle對象 。
三、四種不展現位拷貝語義的場景
3.1什么是位拷貝語義
簡單來說，位拷貝語義指的是對象的復制可以通過直接復制其在內存中的原始字節(jié)來實現 。這就好比是用復印機復印文件，直接將文件的每一個細節(jié)（每一個字節(jié)）都復制下來，生成一個與原文件完全相同的副本。
這種拷貝方式非常簡單直接，效率也很高，尤其適用于那些結構比較簡單的類。比如，一個只包含基本數據類型（如 int、float 等）成員變量，不包含指針、需要特殊拷貝處理的資源或復雜繼承結構的類。假設我們有一個這樣簡單的類：
class SimpleClass {
public:
int num;
float f;
};當我們對SimpleClass類的對象進行拷貝時，使用位拷貝語義就可以輕松實現。例如：
SimpleClass obj1;
obj1.num = 10;
obj1.f = 3.14f;
SimpleClass obj2 = obj1; // 這里進行的就是位拷貝在這個例子中，obj2通過位拷貝從obj1復制而來，obj2的num和f成員變量的值與obj1完全相同，因為位拷貝直接復制了obj1在內存中的字節(jié)內容。這就像是把一個裝滿物品（成員變量值）的盒子（對象），原封不動地復制出另一個一模一樣的盒子，里面的物品也完全一樣。
3.2場景一：內含需要自定義拷貝行為的成員對象
當一個類包含有需要自定義拷貝行為的成員對象時，簡單的位拷貝就無法滿足需求了 。假設我們有一個HasString類，它包含一個std::string類型的成員變量str。
#include <string>
#include <iostream>
class HasString {
public:
HasString(const std::string& s) : str(s) {
std::cout << "HasString構造函數被調用" << std::endl;
}
private:
std::string str;
};在這個例子中，std::string類已經定義了自己的拷貝構造函數，用于執(zhí)行深拷貝，確保每個std::string對象都擁有自己獨立的字符緩沖區(qū) 。當我們創(chuàng)建HasString類的對象并進行拷貝時，如果使用位拷貝語義，會發(fā)生什么呢？
int main() {
HasString hs1("hello");
HasString hs2 = hs1;
return 0;
}在上述代碼中，hs2 = hs1這一操作如果采用位拷貝，hs1和hs2中的str成員將會指向同一塊內存 。這就好比兩個人拿著指向同一文件的指針，當其中一個人修改了文件內容，另一個人看到的文件也會隨之改變。在程序中，如果我們對hs1.str進行修改，hs2.str也會受到影響，這顯然不是我們期望的結果 。
而實際上，這里會調用HasString的默認拷貝構造函數（如果沒有顯式定義），這個默認拷貝構造函數會調用其成員str的拷貝構造函數，即std::string的拷貝構造函數，從而實現深拷貝，保證hs1和hs2的str成員擁有獨立的內存空間 。 所以，當類中包含有自定義拷貝構造函數的成員對象時，不能簡單地使用位拷貝語義，否則會導致數據共享和數據損壞等嚴重問題。
3.3場景二：繼承自具有拷貝構造函數的基類
當一個派生類繼承自一個具有拷貝構造函數的基類時，情況也會變得復雜起來 。假設我們有一個Base類，它包含一個整型成員變量val，并定義了自己的拷貝構造函數 。
#include <iostream>
class Base {
public:
Base(int x) : val(x) {
std::cout << "Base構造函數被調用，val = " << val << std::endl;
}
Base(const Base& other) : val(other.val) {
std::cout << "Base拷貝構造函數被調用，val = " << val << std::endl;
}
private:
int val;
};然后，我們有一個派生類Derived，它繼承自Base類，并新增了一個整型成員變量derivedVal 。
class Derived : public Base {
public:
Derived(int x, int y) : Base(x), derivedVal(y) {
std::cout << "Derived構造函數被調用，derivedVal = " << derivedVal << std::endl;
}
private:
int derivedVal;
};現在，如果我們對Derived類的對象進行拷貝操作，使用位拷貝語義會導致什么問題呢？當我們創(chuàng)建Derived類的對象并進行拷貝時，例如：
int main() {
Derived d1(10, 20);
Derived d2 = d1;
return 0;
}在這個例子中，d2 = d1這一操作如果采用位拷貝，d2的Base類部分（即val成員變量）將不會正確地調用Base類的拷貝構造函數 。這就好比一個有兩個部分組成的拼圖，其中一部分（基類部分）在復制時沒有按照正確的方式拼接，導致整個拼圖（派生類對象）不完整或不正確 。正確的做法是，Derived類的默認拷貝構造函數（如果沒有顯式定義）會調用其基類Base的拷貝構造函數，以確保基類部分的val成員被正確復制 。如果我們顯式定義Derived類的拷貝構造函數，也必須顯式調用基類的拷貝構造函數，否則d2的Base類部分將不會被正確初始化 。例如：
class Derived : public Base {
public:
Derived(int x, int y) : Base(x), derivedVal(y) {
std::cout << "Derived構造函數被調用，derivedVal = " << derivedVal << std::endl;
}
// 顯式定義拷貝構造函數
Derived(const Derived& other) : Base(other), derivedVal(other.derivedVal) {
std::cout << "Derived拷貝構造函數被調用，derivedVal = " << derivedVal << std::endl;
}
private:
int derivedVal;
};這樣，在Derived類的拷貝構造函數中，通過Base(other)顯式調用了基類的拷貝構造函數，確保了基類部分的正確復制 。所以，當派生類繼承自具有拷貝構造函數的基類時，不能簡單地使用位拷貝語義，否則會導致基類部分的復制和初始化不完整，從而引發(fā)程序運行時的錯誤 。
3.4場景三：聲明了一個或多個虛函數
當一個類聲明了一個或多個虛函數時，簡單的位拷貝就會暴露出問題 。虛函數是 C++ 中實現動態(tài)多態(tài)性的重要機制，它允許在派生類中重寫基類的函數，從而在運行時根據對象的實際類型來決定調用哪個版本的函數 。每個包含虛函數的類都有一個虛函數表（VTable），對象中包含一個指向該虛函數表的指針（VPTR） 。這就好比一個圖書館的書架，每個書架都有一個目錄（虛函數表），書架上的每本書（虛函數）都在目錄中有對應的索引。而每本放在書架上的書（對象）都有一個小標簽（VPTR）指向這個目錄，方便快速找到對應的書（函數）。
假設有一個Base類，它聲明了一個虛函數print 。
#include <iostream>
class Base {
public:
virtual void print() {
std::cout << "This is Base" << std::endl;
}
};然后，有一個派生類Derived，它繼承自Base類，并重寫了print函數 。
class Derived : public Base {
public:
void print() override {
std::cout << "This is Derived" << std::endl;
}
};現在，如果我們對Base類的對象進行位拷貝操作，會發(fā)生什么呢？當我們創(chuàng)建Base類和Derived類的對象，并進行拷貝時，例如：
int main() {
Derived d;
Base b = d;
b.print();
return 0;
}在這個例子中，b = d這一操作如果采用位拷貝，b的虛函數指針（VPTR）將指向Base類的虛函數表 。這就像是把一本屬于Derived書架的書（對象d），按照Base書架的目錄（虛函數表）來擺放（位拷貝），導致最后查找書（調用函數）時，按照Base書架的目錄（虛函數表）去查找，找不到正確的書（函數） 。
所以，當調用b.print()時，調用的是Base類的print函數，而不是Derived類的print函數 。這顯然不是我們期望的多態(tài)行為 。正確的做法是，通過定義合適的拷貝構造函數或賦值運算符重載函數，確保在拷貝對象時，虛函數指針（VPTR）能正確地指向目標類的虛函數表 。所以，當類中聲明了虛函數時，不能簡單地使用位拷貝語義，否則會導致虛函數調用錯誤，破壞多態(tài)性的正常實現 。
3.5場景四：繼承鏈中存在一個或多個虛基類
在 C++ 的繼承體系中，虛基類是一種特殊的存在，主要用于解決菱形繼承問題 。當一個類從多個路徑繼承同一個基類時，如果不使用虛基類，會導致該基類在最終的派生類中存在多份拷貝，這不僅浪費內存，還可能引發(fā)命名沖突和訪問歧義等問題 。而虛基類通過虛繼承的方式，使得在派生類中只保留一份基類的實例 。
假設我們有一個經典的菱形繼承結構，如下所示：
class A {
public:
int data;
};
class B : virtual public A {};
class C : virtual public A {};
class D : public B, public C {};在這個例子中，A是虛基類，B和C都通過虛繼承從A派生而來，D又從B和C派生 。這樣，在D類的對象中，A類的成員data只會有一份拷貝 。
現在，如果我們對D類的對象進行位拷貝操作，會發(fā)生什么呢？當我們創(chuàng)建D類的對象并進行拷貝時，例如：
int main() {
D d1;
d1.data = 10;
D d2 = d1;
return 0;
}在這個例子中，d2 = d1這一操作如果采用位拷貝，會導致虛基類A部分的復制和初始化出現嚴重錯誤 。因為位拷貝只是簡單地復制內存中的字節(jié)，它無法正確處理虛基類的特殊結構和初始化邏輯 。虛基類的初始化是由最終派生類（這里是D類）的構造函數通過調用虛基類的構造函數來完成的，并且在整個繼承體系中，虛基類的構造函數只會被調用一次 。
而位拷貝會破壞這種初始化機制，導致d2對象中虛基類A部分的數據處于未正確初始化的狀態(tài)，從而引發(fā)程序運行時的錯誤 。所以，當繼承鏈中存在一個或多個虛基類時，不能簡單地使用位拷貝語義，否則會破壞虛基類的共享機制和初始化邏輯，導致程序出現難以調試的錯誤 。
四、編譯器什么時候生成默認拷貝構造函數
在 C++ 中，編譯器并非總是會為類生成默認的拷貝構造函數。只有在必要的情況下，編譯器才會介入生成，這些必要情況具體如下：
4.1類中含有成員對象
當類中包含其他類類型的成員對象，并且這些成員對象有自己的拷貝構造函數時，編譯器會為該類生成默認的拷貝構造函數。在這個默認拷貝構造函數中，會調用成員類的拷貝構造函數來完成成員對象的復制。
假設我們有兩個類，Point類和Rectangle類，其中Rectangle類包含Point類的對象作為成員變量：
class Point {
public:
int x;
int y;
Point(int a, int b) : x(a), y(b) {}
Point(const Point& other) : x(other.x), y(other.y) {
std::cout << "Point類的拷貝構造函數被調用" << std::endl;
}
};
class Rectangle {
public:
Point topLeft;
Point bottomRight;
Rectangle(int x1, int y1, int x2, int y2) : topLeft(x1, y1), bottomRight(x2, y2) {}
// 此處未定義拷貝構造函數，編譯器會生成默認的
};
int main() {
Rectangle r1(1, 1, 5, 5);
Rectangle r2 = r1; // 觸發(fā)拷貝構造函數
return 0;
}在上述代碼中，Rectangle類沒有顯式定義拷貝構造函數，但它包含Point類的對象topLeft和bottomRight，且Point類有自己的拷貝構造函數。當執(zhí)行Rectangle r2 = r1;時，編譯器會為Rectangle類生成默認的拷貝構造函數，并在其中調用Point類的拷貝構造函數來復制topLeft和bottomRight對象 。我們可以通過查看生成的obj文件來驗證這一點。在obj文件中，可以找到與Rectangle類默認拷貝構造函數相關的信息，其中會包含對Point類拷貝構造函數的調用 。
4.2存在繼承關系
當一個類繼承自另一個類，且父類中有拷貝構造函數時，子類在需要進行拷貝構造時，編譯器會為子類生成拷貝構造函數。在這個生成的拷貝構造函數中，會先調用父類的拷貝構造函數來完成父類部分的復制，然后再處理子類特有的成員變量。
我們以一個簡單的繼承體系為例，有一個Animal類作為父類，Dog類繼承自Animal類：
class Animal {
public:
std::string name;
Animal(const std::string& n) : name(n) {}
Animal(const Animal& other) : name(other.name) {
std::cout << "Animal類的拷貝構造函數被調用" << std::endl;
}
};
class Dog : public Animal {
public:
int age;
Dog(const std::string& n, int a) : Animal(n), age(a) {}
// 未定義拷貝構造函數，編譯器會生成
};
int main() {
Dog d1("Buddy", 3);
Dog d2 = d1; // 觸發(fā)拷貝構造函數
return 0;
}在這段代碼中，Dog類沒有顯式定義拷貝構造函數，但它繼承自Animal類，且Animal類有拷貝構造函數。當執(zhí)行Dog d2 = d1;時，編譯器會為Dog類生成默認的拷貝構造函數。在這個生成的拷貝構造函數中，會首先調用Animal類的拷貝構造函數來復制name成員變量，然后再處理Dog類特有的age成員變量 。通過分析obj文件，我們可以看到生成的Dog類拷貝構造函數中包含了對Animal類拷貝構造函數的調用 。
4.3類中有虛函數
如果一個類中含有虛函數，編譯器會為該類生成拷貝構造函數。這是因為虛函數涉及到虛函數表（vtable），在拷貝對象時，需要正確地處理虛函數表，以確保多態(tài)性的正確實現。編譯器生成的拷貝構造函數會負責拷貝虛函數表指針，使得新對象的虛函數表與原對象一致。
我們來看一個包含虛函數的類Shape：
class Shape {
public:
virtual void draw() const = 0;
int color;
Shape(int c) : color(c) {}
// 未定義拷貝構造函數，編譯器會生成
};
class Circle : public Shape {
public:
int radius;
Circle(int c, int r) : Shape(c), radius(r) {}
void draw() const override {
std::cout << "Drawing a circle" << std::endl;
}
// 未定義拷貝構造函數，編譯器會生成
};
int main() {
Circle c1(255, 5);
Circle c2 = c1; // 觸發(fā)拷貝構造函數
return 0;
}在上述代碼中，Shape類和Circle類都沒有顯式定義拷貝構造函數，但Shape類含有虛函數draw。當執(zhí)行Circle c2 = c1;時，編譯器會為Circle類生成默認的拷貝構造函數，其中會處理虛函數表的拷貝 。查看obj文件時，可以發(fā)現與虛函數表拷貝相關的代碼 ，這表明編譯器在生成的拷貝構造函數中正確地處理了虛函數表，以保證多態(tài)性在拷貝后的對象中依然能夠正常工作。
4.4虛繼承情況
當一個類使用虛繼承時，編譯器會為該類生成拷貝構造函數。虛繼承主要用于解決多重繼承中可能出現的菱形繼承問題，在這種情況下，對象中會包含指向虛基類表（vbtable）的指針。編譯器生成的拷貝構造函數會負責正確地拷貝這個指針以及相關的虛基類數據，確保對象在虛繼承體系中的一致性和正確性。
我們通過一個典型的虛繼承案例來展示，假設有一個虛基類Base，兩個派生類Derived1和Derived2都虛繼承自Base，最后有一個類Final繼承自Derived1和Derived2：
class Base {
public:
int baseData;
Base(int d) : baseData(d) {}
};
class Derived1 : virtual public Base {
public:
Derived1(int d) : Base(d) {}
};
class Derived2 : virtual public Base {
public:
Derived2(int d) : Base(d) {}
};
class Final : public Derived1, public Derived2 {
public:
int finalData;
Final(int b, int f) : Base(b), Derived1(b), Derived2(b), finalData(f) {}
// 未定義拷貝構造函數，編譯器會生成
};
int main() {
Final f1(10, 20);
Final f2 = f1; // 觸發(fā)拷貝構造函數
return 0;
}在這段代碼中，Final類沒有顯式定義拷貝構造函數，但由于它處于虛繼承體系中，當執(zhí)行Final f2 = f1;時，編譯器會為Final類生成默認的拷貝構造函數，其中會處理虛基類表的拷貝 。分析obj文件可以看到，生成的拷貝構造函數中包含了對虛基類表的正確處理，確保了Final類對象在虛繼承體系下的正確拷貝 。
五、構造函數誤區(qū)深度剖析
5.1誤區(qū)一：默認拷貝構造函數適用于所有情況
很多初學者可能會天真地認為，默認拷貝構造函數就像是一個萬能的 “復制機器”，在任何情況下都能完美地完成對象的拷貝任務。但現實卻很 “骨感”，默認拷貝構造函數其實只進行淺拷貝。這就意味著，當類中包含指針成員或者需要動態(tài)分配內存的成員時 ，它僅僅會復制指針的值，而不會復制指針所指向的內存空間。比如說，有這樣一個MyString類：
class MyString {
private:
char* str;
public:
MyString(const char* s) {
str = new char[strlen(s) + 1];
strcpy(str, s);
}
~MyString() {
delete[] str;
}
};在這個類中，str是一個指針，指向動態(tài)分配的內存。當使用默認拷貝構造函數時：
MyString s1("Hello");
MyString s2 = s1;s2的str指針會和s1的str指針指向同一塊內存。這就像是兩個人拿著同一把鑰匙去開同一個房間的門。當s1和s2生命周期結束，先后調用析構函數時，問題就出現了 。s1先調用析構函數釋放了內存，s2再調用析構函數時，就會嘗試釋放一塊已經被釋放的內存，這就會導致程序崩潰，就像是拿著一把已經打不開門的鑰匙去開門，肯定會出錯。而且，如果在s2存在期間，s1修改了其所指向內存中的內容，s2也會受到影響，因為它們指向同一塊內存，這就會導致數據不一致的問題，就像兩個人同時在一個房間里隨意擺放物品，互相干擾 。所以，默認拷貝構造函數并不適用于所有情況，尤其是當類中包含動態(tài)分配內存的成員時，我們需要自定義拷貝構造函數來實現深拷貝，為每個對象分配獨立的內存空間 。
5.2誤區(qū)二：只要不手動調用就不會執(zhí)行
還有一種常見的誤解是，有些人覺得只要自己不在代碼中顯式地調用拷貝構造函數，它就不會被執(zhí)行。但實際上，在很多看似平常的代碼場景中，編譯器會悄悄地自動調用默認拷貝構造函數。比如在對象初始化時，除了直接用=進行初始化會調用拷貝構造函數外，像這樣的情況：
class Point {
public:
int x, y;
Point(int a, int b) : x(a), y(b) {}
};
Point p1(1, 2);
Point p2(p1); // 調用拷貝構造函數這里p2(p1)同樣調用了拷貝構造函數。在函數傳參時，當對象以值傳遞的方式傳入函數：
void printPoint(Point p) {
std::cout << "x: " << p.x << ", y: " << p.y << std::endl;
}
int main() {
Point p(3, 4);
printPoint(p); // 調用拷貝構造函數創(chuàng)建p的副本傳入函數
return 0;
}在printPoint函數調用時，p對象會被拷貝一份傳入函數，即使我們沒有手動寫調用拷貝構造函數的代碼 。在函數返回值時，如果函數返回一個對象：
Point createPoint() {
Point temp(5, 6);
return temp; // 調用拷貝構造函數創(chuàng)建返回值的副本
}
int main() {
Point p = createPoint();
return 0;
}createPoint函數返回temp對象時，也會調用拷貝構造函數創(chuàng)建一個臨時對象作為返回值 。所以，不能簡單地認為不手動調用拷貝構造函數就萬事大吉，要時刻留意這些編譯器自動調用的場景，避免因為不了解而產生的潛在問題 。
5.3誤區(qū)三：和賦值運算符重載混淆
默認拷貝構造函數和默認賦值運算符重載函數，這兩者的功能和調用時機常常讓人傻傻分不清楚。從調用時機來看，默認拷貝構造函數是在創(chuàng)建新對象并使用已有對象對其進行初始化時被調用 ，就像是用一個模子去制作一個新的產品。而默認賦值運算符重載函數則是在兩個已經存在的對象之間進行賦值操作時被調用，它更像是把一個產品的外觀重新涂成另一個產品的樣子。從功能上來說，拷貝構造函數的使命是初始化一個全新的對象，讓新對象擁有和已有對象相同的狀態(tài) 。而賦值運算符重載函數的任務是將一個已存在對象的狀態(tài)復制給另一個已存在的對象 。我們來看下面這段代碼：
class Number {
public:
int value;
Number(int v) : value(v) {}
// 拷貝構造函數
Number(const Number& other) : value(other.value) {
std::cout << "拷貝構造函數被調用" << std::endl;
}
// 賦值運算符重載
Number& operator=(const Number& other) {
if (this != &other) {
value = other.value;
std::cout << "賦值運算符重載函數被調用" << std::endl;
}
return *this;
}
};
int main() {
Number n1(10);
Number n2(n1); // 調用拷貝構造函數
Number n3(20);
n3 = n1; // 調用賦值運算符重載函數
return 0;
}在這段代碼中，Number n2(n1);這一行創(chuàng)建了新對象n2并使用n1進行初始化，所以調用的是拷貝構造函數 。而n3 = n1;這一行是對已經存在的n3進行賦值操作，調用的是賦值運算符重載函數 。通過這樣的對比，就能清楚地看出兩者的區(qū)別，避免在實際編程中因為混淆而導致錯誤 。
六、默認拷貝構造函數詳解
6.1默認拷貝構造函數是什么
在 C++ 中，當我們沒有為類顯式定義拷貝構造函數時，編譯器會在必要的時候為我們生成一個默認拷貝構造函數。這個默認拷貝構造函數是一個特殊的構造函數，它的作用是用一個已存在的對象去初始化一個新的同類對象，執(zhí)行的是成員級別的復制操作 ，也就是逐個成員復制。對于基本類型的成員變量，它會直接復制值；對于類類型的成員變量，會調用其對應的拷貝構造函數進行復制。例如：
class SimpleClass {
public:
int num;
double d;
};對于SimpleClass類，當我們使用如下方式創(chuàng)建對象時：
SimpleClass obj1;
obj1.num = 10;
obj1.d = 3.14;
SimpleClass obj2 = obj1;如果沒有自定義拷貝構造函數，編譯器生成的默認拷貝構造函數會將obj1的num和d成員變量的值直接復制給obj2 。
6.2默認拷貝構造函數何時生成
（1）用戶未自定義拷貝構造函數：當用戶在定義類時，沒有自己編寫拷貝構造函數，并且在代碼中使用到了拷貝構造的場景（如對象初始化、函數參數值傳遞、函數值返回等）時，編譯器會生成默認拷貝構造函數。比如有如下Student類：
class Student {
public:
std::string name;
int age;
};當進行以下操作時：
Student s1;
s1.name = "Alice";
s1.age = 20;
Student s2 = s1;由于Student類沒有自定義拷貝構造函數，編譯器會生成默認拷貝構造函數來完成s2的初始化，將s1的name和age成員變量復制給s2。
（2）用戶定義其他構造函數但非拷貝構造：即使類中定義了其他構造函數（如無參構造函數、有參構造函數等），只要沒有定義拷貝構造函數，并且在代碼中出現了需要拷貝構造的情況，編譯器依然會自動生成默認拷貝構造函數。例如：
class Rectangle {
public:
int width;
int height;
// 有參構造函數
Rectangle(int w, int h) : width(w), height(h) {}
};在使用如下代碼時：
Rectangle r1(5, 3);
Rectangle r2 = r1;雖然Rectangle類定義了有參構造函數，但沒有定義拷貝構造函數，所以在創(chuàng)建r2時，編譯器會生成默認拷貝構造函數來將r1的成員變量width和height復制給r2。
6.3默認拷貝構造函數工作原理
（1）內存層面的操作
默認拷貝構造函數執(zhí)行的是淺拷貝（shallow copy）操作 ，它在內存層面上按照對象的數據成員在內存中的存儲順序，逐字節(jié)地進行復制。例如，有一個包含簡單數據成員的Rectangle類：
class Rectangle {
public:
int width;
int height;
};當使用默認拷貝構造函數創(chuàng)建新對象時：
Rectangle rect1;
rect1.width = 10;
rect1.height = 5;
Rectangle rect2 = rect1;在內存中，rect1 的 width 和 height 成員變量所占據的內存空間中的內容，會被直接復制到 rect2 對應的內存位置上。就好像是在內存中進行了一次 “逐字抄寫”，rect2 的 width 和 height 成員變量獲得了與 rect1 完全相同的值 。
（2）內置類型與自定義類型處理差異
①內置類型處理：對于內置類型（如int、double、char等）的數據成員，默認拷貝構造函數直接進行值拷貝。比如在上面的Rectangle類中，width和height是int類型的內置數據成員，在拷貝時，它們的值會被原封不動地復制到新對象的對應成員變量中 。這種直接的值拷貝簡單高效，因為內置類型的數據存儲方式相對簡單，直接復制其值就可以完成拷貝操作。
②自定義類型處理：當類中包含自定義類型的數據成員時，默認拷貝構造函數會調用該自定義類型的拷貝構造函數來完成拷貝。假設有一個Point類作為Rectangle類的成員：
class Point {
public:
int x;
int y;
Point(const Point& other) {
x = other.x;
y = other.y;
}
};
class Rectangle {
public:
Point topLeft;
int width;
int height;
};當創(chuàng)建Rectangle類的對象并使用默認拷貝構造函數進行拷貝時：
Rectangle rect1;
rect1.topLeft.x = 1;
rect1.topLeft.y = 1;
rect1.width = 10;
rect1.height = 5;
Rectangle rect2 = rect1;對于rect1中的topLeft這個自定義類型的成員變量，默認拷貝構造函數會調用Point類的拷貝構造函數，將rect1.topLeft的x和y成員變量的值復制到rect2.topLeft的對應成員變量中 ，而對于width和height這兩個內置類型成員變量，依然是直接進行值拷貝。
6.4什么時候需要自定義拷貝構造函數
（1）淺拷貝的潛在問題
默認拷貝構造函數執(zhí)行的淺拷貝操作雖然在大多數簡單情況下能夠滿足基本的對象復制需求，但當類中包含指針成員時，淺拷貝會暴露出嚴重的問題。例如，有一個String類用于管理字符串：
class String {
public:
char* str;
int length;
String(const char* s) {
length = strlen(s);
str = new char[length + 1];
strcpy(str, s);
}
~String() {
delete[] str;
}
};當使用默認拷貝構造函數進行對象拷貝時：
String s1("Hello");
String s2 = s1;在這個例子中，s2的str指針會直接指向 s1.str所指向的內存地址，即 s1和 s2的str指針指向同一塊內存空間。這就帶來了一系列潛在風險 ：
- 內存重復釋放：當 s1和 s2的生命周期結束時，它們的析構函數會先后被調用。由于 s1和 s2的str指針指向同一塊內存， s1的析構函數釋放內存后， s2的析構函數再試圖釋放這塊已經被釋放的內存，就會導致程序崩潰。
- 野指針問題：如果在 s1的析構函數執(zhí)行后， s2還試圖訪問str指針所指向的內存，此時str就成為了野指針，因為它所指向的內存已經被釋放，訪問野指針會導致未定義行為，程序可能出現各種奇怪的錯誤，如數據讀取錯誤、程序崩潰等 。
- 數據一致性問題：當通過 s1修改str所指向的字符串內容時，由于 s2的str指向同一塊內存， s2的字符串內容也會隨之改變。這可能會導致程序中不同部分對同一 “邏輯上獨立” 的對象產生不一致的理解，破壞了數據的獨立性和一致性 。
（2）深拷貝的必要性與實現方式
當類中涉及資源申請（如動態(tài)內存分配）時，為了避免淺拷貝帶來的問題，就需要自定義深拷貝構造函數 。深拷貝構造函數會為新對象的指針成員重新分配內存空間，并將原對象指針所指向的內容復制到新的內存空間中，使得新對象和原對象在內存上完全獨立，互不影響。以剛才的String類為例，實現深拷貝構造函數如下：
class String {
public:
char* str;
int length;
String(const char* s) {
length = strlen(s);
str = new char[length + 1];
strcpy(str, s);
}
// 深拷貝構造函數
String(const String& other) {
length = other.length;
str = new char[length + 1];
strcpy(str, other.str);
}
~String() {
delete[] str;
}
};在上述代碼中，深拷貝構造函數String(const String& other)首先為新對象的str指針分配與other.str相同大小的內存空間，然后使用strcpy函數將other.str所指向的字符串內容復制到新分配的內存中 。這樣， s1和 s2的str指針就分別指向不同的內存空間，對 s1的字符串內容進行修改不會影響到 s2，并且在對象析構時，各自釋放自己的內存空間，避免了內存重復釋放和野指針問題 。通過自定義深拷貝構造函數，我們有效地解決了淺拷貝帶來的潛在風險，確保了對象在拷貝過程中的數據完整性和內存安全性 。
七、C++拷貝構造函數相關面試題
7.1 C++什么時候會生成默認拷貝構造函數？
答案：通常，若用戶沒定義自己的拷貝構造函數，編譯器在必要時會生成默認拷貝構造函數。常見的 “必要情況” 包含以下幾種：
- 類的成員變量是類類型，且該成員類存在拷貝構造函數。為調用其拷貝構造函數，編譯器要為當前類生成默認拷貝構造函數。
- 類繼承自一個存在拷貝構造函數的基類。子類拷貝需先調用父類拷貝構造函數，因而需生成默認拷貝構造函數以確保可調用父類對應的函數。
- 類內包含虛函數。默認拷貝構造函數可保證虛函數表指針能被正確拷貝，避免位拷貝致使虛函數表指針混亂，進而破壞多態(tài)機制。
- 類繼承自包含虛函數的基類。為在拷貝子類對象時正確處理基類部分虛函數表指針等，需生成默認拷貝構造函數來調用基類拷貝動作。
7.2若類僅包含基本數據類型成員，會生成默認拷貝構造函數嗎？
答案：這種狀況下編譯器一般不會真正生成默認拷貝構造函數實體。類符合位拷貝語義，對象拷貝時，編譯器采用默認逐個成員初始化的方式，其效果類似調用了拷貝構造函數，但不涉及實際的拷貝構造函數合成操作。
7.3默認拷貝構造函數的行為特點是什么？
答案：默認拷貝構造函數會針對基本類型成員執(zhí)行按字節(jié)復制，針對類類型的成員變量，調用其對應的拷貝構造函數。它實施的通常是淺拷貝，若類存在指針或動態(tài)分配資源，則可能引發(fā)問題。
7.4有指針成員的類使用默認拷貝構造函數可能產生什么問題？
答案：易導致淺拷貝問題。默認拷貝構造函數復制指針成員時僅復制地址，會使兩個對象的指針指向同一塊內存。一個對象釋放該內存后，另一個對象的指針變?yōu)閼铱罩羔槪罄m(xù)使用或釋放它都可能引發(fā)程序崩潰或內存錯誤。
7.5定義了帶參構造函數后，還會生成默認拷貝構造函數嗎？
答案：會。定義帶參構造函數僅影響默認無參構造函數的生成，與默認拷貝構造函數的生成邏輯無關聯。只要沒定義拷貝構造函數，且存在需要它的場景，編譯器依舊會生成默認拷貝構造函數。
7.6類繼承場景下，派生類的默認拷貝構造函數如何處理基類部分？
答案：派生類默認拷貝構造函數會先調用基類的拷貝構造函數以初始化派生對象的基類部分。若基類無自定義拷貝構造函數，就調用基類的默認拷貝構造函數。
7.7若明確不想讓類使用默認拷貝構造函數，有什么辦法？
答案：可將拷貝構造函數聲明為 private 且不提供實現，防止外部代碼調用它。C++11 之后，還能夠使用 = delete 語法顯式刪除拷貝構造函數，像 ClassName(const ClassName&) = delete;，讓編譯器禁用它。
7.8虛繼承時，默認拷貝構造函數有什么特殊處理？
答案：虛繼承存在虛基類子對象共享等復雜情況。默認拷貝構造函數需確保虛基類部分在拷貝時僅被復制一次，避免重復復制，并保證虛基類指針或偏移量等能被合理初始化，防止對象模型出錯。
7.9 C++11 的移動構造函數存在時，默認拷貝構造函數生成邏輯受影響嗎？
答案：不受影響。移動構造函數處理右值對象資源轉移，拷貝構造函數負責左值對象拷貝，兩者場景不同。沒定義拷貝構造函數且需進行左值拷貝動作時，編譯器依舊會生成默認拷貝構造函數。
7.10如何判斷程序是否調用了默認拷貝構造函數？
答案：可借助調試工具設置斷點跟蹤。或在類的析構函數中加入輸出語句等標記信息，依據程序運行中析構函數和其他邏輯的執(zhí)行順序、輸出內容，結合對象拷貝場景，大致判斷是否有默認拷貝構造函數參與對象構造過程。此外，查看編譯生成的匯編代碼，判斷有無執(zhí)行類似調用拷貝構造函數的指令，也能確認其是否被調用。
