C++构造函数调用规则详解：默认、拷贝、移动一次说清-代码聚汇网

C++构造函数调用规则详解：默认、拷贝、移动一次说清

C++构造函数拷贝构造

|难度：普通|阅读约 34 分钟

用一句口诀讲清楚C++的构造函数调用规则

工作里见过太多人在构造函数上翻车：定义了一个带参构造，以为默认构造还在，结果一编译报错半天摸不着头脑；或者函数参数传了一个对象进去，莫名其妙拷了好几回，性能直接被打穿。这些问题的根源几乎都是同一个——没搞懂构造函数到底什么时候被调用、被谁调用、为什么不按“直觉”调用。

严格说，构造函数调用规则不是一条规则，而是一组由编译器强制执行的选择逻辑。C++标准里写得清清楚楚，但很少有人把它整理成一套能直接“照着走”的心智模型。这篇就把这摊事彻底捋明白：从构造函数分类讲起，到三条核心调用规则，再到继承、拷贝省略、std::move这些进阶场景，最后附上一批我实际踩过的坑和排查经验。

1. 先把构造函数分成三大家

1.1 默认构造函数：没有参数，但不等于“自动存在”

默认构造函数是指不需要实参就能调用的构造函数，它可以完全没参数，也可以所有参数都有默认值。

cpp复制class Config {
public:
    Config() : timeout_(30) {}              // 纯无参版本
    Config(int timeout = 30) : timeout_(timeout) {}  // 全缺省版本，也是默认构造
private:
    int timeout_;
};

这里第一个坑就来了：你写了一个带参构造函数，编译器就不会再生成默认构造。很多人以为“默认构造函数=编译器一定给我生成一个”，这是误解。编译器生成默认构造只有一种情况——类里没有任何用户声明的构造函数。

cpp复制class Server {
public:
    Server(int port) : port_(port) {}   // 用户声明了带参构造
    // 此时 Server() 不存在，编译器不会悄悄帮你补
private:
    int port_;
};

Server s;          // 编译错误：没有默认构造函数
Server s2(8080);   // 正确

这个行为背后是有逻辑的：如果一个类已经声明了带参构造，说明你明确需要“带参才能初始化”的语义。编译器再自动生成无参构造，反而容易掩盖设计问题。

1.2 拷贝构造函数：用已有对象生成本对象的副本

拷贝构造函数的正式形态是 T(const T&)，也可以用 T(T&)、T(volatile T&) 等变体，但实际工程里几乎只用 const T&。

cpp复制class Buffer {
public:
    Buffer(const Buffer& other) : size_(other.size_), data_(new char[other.size_]) {
        std::copy(other.data_, other.data_ + size_, data_);
    }
private:
    char* data_;
    int size_;
};

简单说：用同类型的对象去初始化另一个新对象，走拷贝构造。 你可以显式写 Buffer b2(b1)，也可以写 Buffer b2 = b1——注意这里是初始化，不是赋值。

1.3 移动构造函数（C++11以后绕不开）

移动构造的形态是 T(T&&)，它接管对方资源而不是复制。

cpp复制class Buffer {
public:
    Buffer(Buffer&& other) noexcept : data_(other.data_), size_(other.size_) {
        other.data_ = nullptr;
        other.size_ = 0;
    }
};

判断走移动还是拷贝，就看实参是左值还是右值。临时对象、std::move() 显式转换出来的对象，都算右值，优先匹配移动构造。这个规则在后续的容器操作里影响巨大。

需要模型API调用？免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。

2. 三大调用规则：什么时候调哪个构造函数

2.1 规则一：各类初始化语法怎么选构造函数

初始化对象有四种常见写法，很多人以为它们是一回事，实际上编译器的选择完全不一样。

cpp复制ClassA a1;            // 默认构造
ClassA a2(10);        // 带参构造
ClassA a3 = 10;       // 看情况：explicit 不存在且存在匹配的话，等价于 ClassA a3(10)
ClassA a4 = a1;       // 拷贝构造
ClassA a5(a1);        // 拷贝构造
ClassA a6 = std::move(a1); // 移动构造

逐行解释下：

a1：调用默认构造。
a2：直接初始化，找匹配的带参构造。
a3：这行最容易错。它叫赋值式初始化，但并不是“先构造临时对象再赋值”，而是直接调用匹配的构造函数。如果构造函数被 explicit 修饰，这里就会编译失败。
a4/a5：把 a1 拷一份，拷贝构造。
a6：std::move 把 a1 转成右值，优先移动构造。如果移动构造没定义，编译器会尝试拷贝构造，但这里有个性能陷阱，后面会讲。

这里需要重点强调 explicit。它不只是一个编译器符号，更是设计态度：不希望发生隐式转换就用它，否则你会在不知不觉中让一个整数在函数调用边界上发生奇怪的自动转型。

cpp复制class Port {
public:
    explicit Port(int p) : p_(p) {}
private:
    int p_;
};

void listen(Port p);

listen(8080);   // 编译错误：explicit 禁止隐式转换
listen(Port(8080)); // 正确

2.2 规则二：函数参数传参和返回值时调用哪个构造函数

这是整套规则里最容易出性能问题的地方。

cpp复制void process(Buffer b);            // 按值传参：实参拷进形参时调用拷贝/移动构造
Buffer getBuffer() {
    Buffer b;
    return b;                      // 把局部对象传回调用方：移动或拷贝，也可能省略
}

传参时，如果实参是左值就拷一份，如果实参是临时对象或 std::move 出来的右值，就走移动构造。如果类只定义了拷贝构造没定义移动构造，传右值时也会退回到拷贝构造——这个行为合法但不高效。

返回值的情况更微妙。C++17 之前叫作“复制省略”，C++17 之后叫作“保证复制省略”。当返回一个未命名的临时对象时，编译器可以直接在调用方内存位置上构造，不调用移动也不调用拷贝。当返回命名对象时，早期编译器会尝试先移动，再退化到拷贝，但多数主流编译器做了返回值优化（RVO/NRVO），直接省略掉移动或者拷贝。

cpp复制Buffer makeBuffer() {
    Buffer result;
    // 对 result 做一些操作
    return result;   // NRVO：直接把 result 构造在调用方，而不是先拷贝/移动到临时对象
}

这意味着一个现象：你看到代码里写了拷贝构造，实际运行时可能一次拷贝都没有发生。

2.3 规则三：容器操作、数组初始化和继承体系里的调用

容器是另一个重灾区。std::vector 的 push_back、emplace_back、resize 都会触发不同的构造路径。

cpp复制std::vector<Item> items;
items.reserve(10);

Item x;
items.push_back(x);            // 拷贝构造
items.push_back(Item());       // 先构造临时对象，再把临时对象移动进容器
items.emplace_back();          // 直接在容器内存上构造，没有任何移动和拷贝

这里的关键理解是：emplace_back 和 push_back 的本质区别在于构造发生的位置。push_back 收到一个已经构造好的对象，然后把它搬进去；emplace_back 直接把参数转交给构造函数，在容器预留的内存上现场构造。

数组初始化的情况容易被人