C++构造函数调用方法全解析：从基础语法到高级应用

1次阅读

共计 2696 个字符，预计需要花费 7 分钟才能阅读完成。

构造函数是 C ++ 中管理对象生命周期的核心机制。通过 RAII（Resource Acquisition Is Initialization）原则，构造函数确保对象在创建时就处于有效状态。这种设计模式将资源获取与对象初始化绑定，极大简化了内存、文件句柄等资源的管理。

对象初始化 ：构造函数在对象创建时自动调用，确保成员变量处于合理初始状态
资源获取 ：在构造函数中申请资源（如动态内存、文件句柄），在析构函数中释放
类型转换控制 ：通过 explicit 关键字管理隐式转换行为
继承体系基础 ：派生类构造需要先构造基类部分

在实际开发中，构造函数相关的问题经常让开发者头疼：

隐式转换导致的意外行为

class MyString {
public:
    MyString(const char*); // 可能引起意外转换
};

void func(MyString s);
func("hello"); // 隐式转换发生

继承链中的初始化顺序混乱
基类成员未初始化导致派生类访问无效数据
虚基类初始化顺序的特殊性

对象切片问题

class Base {/*...*/};
class Derived : public Base {/*...*/};

Derived d;
Base b = d; // 切片发生，Derived 部分信息丢失

移动语义理解不足
误用拷贝构造导致性能损失
未正确实现移动构造函数

class Widget {
public:
    Widget();               // 默认构造
    Widget(int x);          // 普通构造
    Widget(const Widget&);  // 拷贝构造
    Widget(Widget&&);       // 移动构造 (C++11)
};

// 调用示例
Widget w1;          // 默认构造
Widget w2(42);      // 普通构造
Widget w3(w2);      // 拷贝构造
Widget w4(std::move(w3)); // 移动构造

class Employee {
    std::string name;
    int id;
    double salary;
public:
    // 主构造函数
    Employee(std::string n, int i, double s) 
        : name(std::move(n)), id(i), salary(s) {}

    // 委托构造
    Employee() : Employee("", 0, 0.0) {}
    Employee(std::string n) : Employee(std::move(n), 0, 0.0) {}};

class DatabaseHandle {
public:
    explicit DatabaseHandle(const std::string& connStr) {// 显式构造防止意外转换}
};

void connectDB(DatabaseHandle h);

// connectDB("localhost:3306"); // 错误！必须显式构造
connectDB(DatabaseHandle("localhost:3306")); // 正确

class Base {
protected:
    int baseData;
public:
    Base(int x) : baseData(x) {std::cout << "Base constructed\n";}
};

class Derived : public Base {
    int derivedData;
public:
    // 必须通过初始化列表构造基类
    Derived(int x, int y) : Base(x), derivedData(y) {std::cout << "Derived constructed\n";}
};

class Buffer {
    char* data;
    size_t size;
public:
    // 移动构造
    Buffer(Buffer&& other) noexcept 
        : data(other.data), size(other.size) {
        other.data = nullptr; // 源对象置空
        other.size = 0;
    }

    // 移动赋值
    Buffer& operator=(Buffer&& other) noexcept {if(this != &other) {delete[] data;  // 释放现有资源
            data = other.data;
            size = other.size;
            other.data = nullptr;
            other.size = 0;
        }
        return *this;
    }

    ~Buffer() { delete[] data; }
};

构造函数调用可能成为性能瓶颈的几种情况：

虚函数表开销
含有虚函数的类需要初始化 vptr
虚继承会引入额外的指针开销
多重继承问题
每个基类都需要单独构造
可能导致多次内存跳转
大对象拷贝
未正确实现移动语义时
深拷贝带来的性能损耗

对基类使用引用或指针
将基类声明为 abstract（含纯虚函数）

class AbstractBase {
public:
    virtual ~AbstractBase() = 0;
    virtual void interface() = 0;};

AbstractBase::~AbstractBase() {} // 纯虚析构仍需实现

构造函数失败时应保证不会资源泄漏
使用智能指针管理资源

class SafeResource {
    std::unique_ptr<Resource> res;
public:
    SafeResource() : res(new Resource()) {if(!res->initialize()) {throw std::runtime_error("Init failed");
        }
    }
};

class Base {
public:
    Base() {
        // 错误！此时派生类尚未构造
        doSomething();}

    virtual void doSomething() = 0;};

// 正确做法：使用两段式初始化
class SafeBase {
public:
    SafeBase() {}
    void init() { doSomething(); } // 显式调用
    virtual void doSomething() = 0;};