C++ 構造函數全面深度解析：重載、默認參數、拷貝、轉換、explicit 與最佳實踐

構造函數在 C++ 對象生命週期中的核心地位

構造函數是類類型對象自動初始化的保證。它在對象創建時（定義變量、new、臨時對象、容器插入、函數返回等）由編譯器隱式調用，確保對象從一出生就處於有效狀態。C++ 提供了豐富的構造函數機制以適應各種初始化場景。

1. 構造函數重載 — 多種初始化方式

同一類可定義多個構造函數，參數列表必須不同（個數、類型、順序）。對象定義時根據實參匹配調用唯一的一個。

class Point {
    int x_, y_;
public:
    Point() : x_(0), y_(0) {}                    // 默認構造
    Point(int x, int y) : x_(x), y_(y) {}        // 兩參數
    Point(int val) : x_(val), y_(val) {}         // 單參數 (對角線點)
    // Point(double x, double y) : x_(x), y_(y) {} // 錯誤: 與 (int,int) 在整型提升後可能衝突
};

Point p1;          // Point()
Point p2(3, 4);    // Point(int,int)
Point p3(5);       // Point(int) -> (5,5)
Point p4 = 10;     // 隱式轉換: Point(10) -> (10,10) 見第 4 節

重載決議陷阱

• Point(int) 和 Point(double) 共存時，Point(3.14) 匹配 double，Point(3) 匹配 int。
• Point(int, int=0) (默認參數) 與 Point(int) 衝突：Point(3) 二義性。
• 最佳實踐：避免同時使用重載和默認參數；單參數構造函數加 explicit (見第 5 節)。

2. 帶默認參數的構造函數 — 減少重載數量

默認參數只能在類內聲明處指定，不可在類外定義時重複。

class Config {
    std::string host_;
    int port_;
    int timeout_;
public:
    // 一個構造函數覆蓋 4 種調用方式
    Config(std::string host = "localhost", int port = 8080, int timeout = 30)
        : host_(std::move(host)), port_(port), timeout_(timeout) {}
};

Config c1;                    // 全部默認
Config c2("192.168.1.1");     // 僅指定 host
Config c3("host", 9090);      // 指定 host, port
Config c4("h", 80, 60);       // 全部指定

默認參數與重載衝突示例

class Bad {
public:
    Bad(int a = 1, int b = 1) {} // 所有參數有默認值 = 默認構造函數
    Bad() {}                     // 錯誤: 與上行構成二義性，Bad b; 編譯失敗
};

3. 默認構造函數 — 對象無參創建的基石

默認構造函數 = 可無實參調用的構造函數（無參版、或所有參數有默認值）。

• 合成默認構造函數：若類未聲明任何構造函數，編譯器隱式生成一個公有的、內聯的、無參構造函數，對非靜態數據成員按其類型規則初始化（類類型調用其默認構造，內建類型不初始化，值不確定）。
• 用戶聲明任意構造函數 → 編譯器不再生成合成默認構造函數。若仍需無參創建，必須顯式定義 ClassName() 或提供全默認參數版本。
• 標準容器要求：std::vector<T>、std::map<K,V> 等要求 T 可默認構造 (C++11 起部分需求放寬，但仍廣泛需要)。

class Widget {
    int id_; // 內建類型
public:
    Widget(int id) : id_(id) {} // 用戶聲明了帶參構造
    // Widget() {} // 必須顯式提供，否則 Widget w; 編譯錯誤
    // 或 Widget(int id = 0) : id_(id) {} 合併
};

4. 隱式類類型轉換 — 單參數構造函數的雙刃劍

可用單個實參調用的構造函數（含除第一參數外全有默認值的多參數版本）定義了從實參類型到類類型的隱式轉換序列。

class Data {
    std::string s_;
public:
    Data(const std::string& str = "") : s_(str) {} // 轉換構造函數
    void set(const Data& d) { s_ = d.s_; }
};

void func(const Data& d) { /*...*/ }

Data d1("hello");     // 直接構造
Data d2 = "world";   // 隱式轉換: string -> Data (拷貝初始化)
func("temp");        // 隱式轉換: string -> Data 臨時對象 -> const Data&
d2.set("again");     // 隱式轉換: string -> Data 臨時對象 -> const Data&

隱式轉換的風險

• 意外調用：func(10) 可能匹配 func(Data) 而非預期的 func(int)。
• 臨時對象創建開銷：隱式轉換產生臨時對象，可能導致性能下降或邏輯錯誤 (如持有指針的類)。
• 語義模糊：Data d = 3.14; 是構造還是賦值？實為構造。

5. explicit 關鍵字 — 禁止隱式轉換

在構造函數聲明前加 explicit，禁用拷貝初始化和隱式轉換，僅允許直接初始化 (括號/花括號) 和強制轉換 (static_cast/C-style cast)。

class SafeData {
    std::string s_;
public:
    explicit SafeData(const std::string& str = "") : s_(str) {} // explicit
    // explicit SafeData(int len) : s_(len, ' ') {} // 也可用於多參數 (C++11)
};

SafeData sd1("ok");        // ✅ 直接初始化
SafeData sd2 = "bad";      // ❌ 編譯錯誤: 拷貝初始化被禁止
// func("temp");           // ❌ 編譯錯誤: 隱式轉換被禁止
func(SafeData("temp"));    // ✅ 顯式構造臨時對象
func(static_cast<SafeData>("temp")); // ✅ 強制轉換

explicit 最佳實踐

「除非有極強理由需要隱式轉換，否則所有單參數構造函數（以及多參數但除第一外全有默認值的）都應聲明為 explicit。」 — C++ Core Guidelines C.46

• 標準庫中 std::string、std::vector、std::shared_ptr、std::unique_ptr、std::chrono::duration 等單參數構造均為 explicit。
• C++20 引入 explicit(bool) 條件顯式，可根據模板參數動態決定。

6. 拷貝構造函數 — 對象複製的語義定義

形式：ClassName(const ClassName& other) (也可非 const，但極少用)。用於：

• 變量初始化：T t2 = t1; (拷貝初始化)
• 按值傳參：void func(T t); func(t1);
• 按值返回：T func() { T t; return t; } (可能觸發 RVO/NRVO 優化)
• 容器插入：vec.push_back(t1);

默認拷貝構造 (合成)

若未聲明，編譯器生成逐成員拷貝：按順序調用每個非靜態數據成員的拷貝構造函數。適用於無資源管理的類 (POD、僅含值類型成員)。

深拷貝 vs 淺拷貝

class DeepString {
    char* data_;
    size_t len_;
public:
    DeepString(const char* s = "") { /* 分配內存並拷貝 */ }
    ~DeepString() { delete[] data_; }
    
    // 必須自定義深拷貝
    DeepString(const DeepString& other) : len_(other.len_) {
        data_ = new char[len_ + 1];
        std::memcpy(data_, other.data_, len_ + 1);
    }
    // 同理需要拷貝賦值運算符 operator=
    // C++11 還需移動構造/移動賦值 (Rule of Five)
};

三/五法則

7. 現代 C++ 初始化最佳實踐總結

構造函數設計清單

1. 成員初始化列表：強制使用初始化列表初始化成員，而非函數體賦值。對於 const、引用、無默認構造的成員、基類子對象，只能在列表中初始化。
2. 避免隱式轉換：單參數構造函數默認加 explicit。
3. 默認構造函數：若類需支持無參創建，務必提供 (顯式或合成)。
4. 委托構造 (C++11)：構造函數調用同類其他構造函數避免代碼重複。

   class A {
           int x_, y_;
       public:
           A(int x, int y) : x_(x), y_(y) {}
           A(int x) : A(x, 0) {}      // 委托
           A() : A(0) {}              // 委托
       };

5. 繼承構造 (C++11)：using Base::Base; 繼承基類構造函數 (除默認/拷貝/移動)。
6. 聚合初始化：若類滿足聚合條件 (無用戶聲明構造、無私有/受保護非靜態成員、無虛函數/虛基類)，可用花括號直接初始化：Point p{1,2};。
7. 禁止拷貝/移動：不可拷貝類型 (如 std::mutex、std::unique_ptr、IO 流) 應 = delete 拷貝操作，或繼承 boost::noncopyable / 自定義基類。

對象創建語法對比 (C++11 統一初始化)

Widget w1;              // 默認構造
Widget w2{};            // 默認構造 (值初始化，成員為 0/null)
Widget w3(10);          // 直接初始化
Widget w4{10};          // 列表初始化 (優先匹配 initializer_list 構造)
Widget w5 = 10;         // 拷貝初始化 (需非 explicit)
Widget w6 = {10};       // 拷貝列表初始化
auto w7 = Widget(10);   // 直接初始化 (臨時對象 + 移動/複製省略)
Widget* pw = new Widget(10); // 動態分配
std::vector<Widget> v(10);   // 10 個默認構造 Widget

總結

構造函數是 C++ 類類型不變量建立的核心機制。掌握重載決議、默認參數陷阱、合成默認構造條件、隱式轉換風險與 explicit 防禦、拷貝/移動語義與 Rule of Zero/Three/Five、委托/繼承/聚合初始化現代特性，能編寫出安全、高效、符合直覺的類接口。核心原則：顯式優於隱式，值語義優於引用語義，RAII 管理資源，編譯器輔助檢查。

1. 上一篇文章： C/C++ 八大經典排序算法原理與實現完全指南
2. 下一篇文章： C++ 虛函數機制深度解析：虛表、動態綁定與虛析構函數

關於C++

HDU 2191 珍惜現在，感恩生活：多重背包問題

題目背景 紀念汶川大地震。有 n 元資金，m 種大米，每種有

POJ 2411 Mondriaan's Dream：狀壓 DP 填充矩形計數

POJ 2411「Mondriaans Dream」：h×w

Qt學習之路(31)：使用 QWidget 實作簡易畫板

原本我不打算放一個過於複雜的範例，畢竟講解起來可能需要好幾篇

OpenCL 精確字串搜尋：大文本 GPU 並行模式匹配實現

問題背景與加速策略 精確字串搜尋在資訊安全、日誌分析、基因序