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

1次阅读

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

在开始探讨构造函数调用方法之前，我们先看两个新手常犯的错误案例，这些错误往往源于对构造函数调用的理解不够深入。

隐式转换导致的意外行为

class StringWrapper {
public:
    StringWrapper(const char* str) : data(str) {}
    // ... 其他成员函数
private:
    std::string data;
};

void processString(const StringWrapper& wrapper) {// 处理字符串}

int main() {processString("Hello"); // 隐式转换发生
    return 0;
}

这段代码看起来没什么问题，但实际上它可能导致意外的隐式转换。当传递一个 const char* 给processString时，编译器会自动调用 StringWrapper 的构造函数创建一个临时对象。这种隐式转换可能导致性能开销，更重要的是，它可能掩盖了潜在的错误。

拷贝构造与对象切割

class Base {
public:
    virtual void print() { std::cout << "Base" << std::endl;}
};

class Derived : public Base {
public:
    void print() override { std::cout << "Derived" << std::endl;}
};

void func(Base b) {b.print();
}

int main() {
    Derived d;
    func(d); // 对象切割发生
    return 0;
}

在这个例子中，当我们传递 Derived 对象给 func 时，会发生对象切割，丢失派生类的特性。这是因为参数是按值传递的，会调用 Base 的拷贝构造函数。

class Example {
public:
    Example() : x(0), y(0.0) {} // 默认构造函数
    // ...
private:
    int x;
    double y;
};

int main() {
    Example e1;        // 默认初始化
    Example e2{};      // 值初始化(C++11)
    Example* p = new Example(); // 值初始化
    return 0;
}

忘记初始化内置类型成员变量（可能导致 UB）
混淆 Example e; 和Example e();（后者是函数声明）
依赖未初始化的内置类型静态变量（零初始化规则复杂）

对于Example e;，内置类型成员不会被初始化
对于 Example e{}; 或Example()，内置类型成员会被值初始化（零）
静态存储期的变量会被零初始化

class Widget {
public:
    Widget(int value) : data(value) {}
    Widget(const Widget& other) : data(other.data) {}
    // ...
private:
    int data;
};

int main() {Widget w1(10);       // 直接初始化
    Widget w2 = 20;      // 拷贝初始化（可能涉及隐式转换）Widget w3 = w1;      // 拷贝初始化
    Widget w4(w1);       // 直接初始化
    return 0;
}

使用 = 形式时忽略可能的隐式转换
没有禁用不需要的拷贝构造函数
在拷贝构造函数中没有正确处理深拷贝

现代编译器通常会进行返回值优化（RVO）和命名返回值优化（NRVO），避免不必要的拷贝操作。

Widget createWidget() {return Widget(42); // 可能被优化为直接构造
}

class Container {
public:
    Container(std::initializer_list<int> list) 
        : elements(list) {}
    // ...
private:
    std::vector<int> elements;
};

int main() {Container c1{1, 2, 3}; // 统一初始化
    Container c2 = {4, 5, 6}; // 也是统一初始化
    int x{5}; // 内置类型也可以用
    return 0;
}

与 auto 一起使用时可能推导出std::initializer_list
窄化转换会被禁止（如 int x{5.5}; 会编译错误）
优先级问题：如果有 initializer_list 构造函数，它会被优先匹配

大括号初始化会禁止窄化转换
对于聚合类型，大括号初始化有特殊的初始化规则
如果没有 initializer_list 构造函数，参数会被正常匹配

class ResourceHolder {
public:
    ResourceHolder() : data(new int[100]) {}

    // 移动构造函数
    ResourceHolder(ResourceHolder&& other) noexcept 
        : data(other.data) {other.data = nullptr;}

    // 完美转发构造函数
    template<typename... Args>
    ResourceHolder(Args&&... args) 
        : data(std::forward<Args>(args)...) {}

    ~ResourceHolder() { delete[] data; }

    // 删除拷贝操作
    ResourceHolder(const ResourceHolder&) = delete;
    ResourceHolder& operator=(const ResourceHolder&) = delete;

private:
    int* data;
};

int main() {
    ResourceHolder rh1; // 默认构造
    ResourceHolder rh2(std::move(rh1)); // 移动构造
    ResourceHolder rh3(100); // 完美转发构造
    return 0;
}

忘记将移动构造函数标记为noexcept
在移动操作后没有将源对象置于有效状态
完美转发构造函数与拷贝构造函数冲突

当对象是右值时，优先匹配移动构造函数
标准库容器在重新分配内存时会使用移动操作（如果noexcept）
完美转发构造函数可能导致意外的模板实例化

#include <vector>
#include <utility>

class ComprehensiveExample {
public:
    // 默认构造
    ComprehensiveExample() : id(0), data() {}

    // 直接构造
    explicit ComprehensiveExample(int id) : id(id), data() {}

    // 拷贝构造
    ComprehensiveExample(const ComprehensiveExample& other) 
        : id(other.id), data(other.data) {}

    // 移动构造
    ComprehensiveExample(ComprehensiveExample&& other) noexcept
        : id(other.id), data(std::move(other.data)) {other.id = 0;}

    // 统一初始化构造
    ComprehensiveExample(std::initializer_list<int> list)
        : id(list.size()), data(list) {}

    // 完美转发构造
    template<typename T>
    ComprehensiveExample(T&& arg) : id(1), data{std::forward<T>(arg)} {}

    // 赋值操作符等略...

private:
    int id;
    std::vector<int> data;
};

通过简单的基准测试（使用<chrono>），我们可以观察到不同构造方式的性能差异：

对于小型对象（如含有一个 int 成员）：
默认构造：约 3ns
拷贝构造：约 5ns
移动构造：约 4ns
对于大型对象（如含有 10000 个 int 的 vector）：
拷贝构造：约 20000ns
移动构造：约 50ns

场景	推荐方式	注意事项
默认初始化	`T obj{}`	避免使用 `T obj()` 语法
带参数构造	`T obj(arg)`	或`T obj{arg}`
避免隐式转换	`explicit`构造函数	特别是单参数构造函数
容器初始化	`T obj{1,2,3}`	使用初始化列表
临时对象	`T{arg}`	配合移动语义
资源管理类	提供移动构造	标记`noexcept`
泛型代码	完美转发	注意与拷贝构造的冲突