Effective STL 条款 03:容器中的对象复制要廉价且正确
- [📐 图解核心](#📐 图解核心)
- [🎯 为什么这很重要?](#🎯 为什么这很重要?)
- [🔬 关键代码](#🔬 关键代码)
- [⚠️ 常见坑与对策](#⚠️ 常见坑与对策)
- [🧠 记住这一条](#🧠 记住这一条)
- [📎 延伸阅读](#📎 延伸阅读)
💡 一句话核心:容器是"值语义"的:放进去的是副本,插入、扩容、删除、排序几乎都在复制或赋值;让拷贝既便宜又正确,比换什么容器都重要。
📐 图解核心
#mermaid-svg-PeO7OzQbzLpXRAKh{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-PeO7OzQbzLpXRAKh .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-PeO7OzQbzLpXRAKh .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-PeO7OzQbzLpXRAKh .error-icon{fill:#552222;}#mermaid-svg-PeO7OzQbzLpXRAKh .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-PeO7OzQbzLpXRAKh .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-PeO7OzQbzLpXRAKh .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-PeO7OzQbzLpXRAKh .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-PeO7OzQbzLpXRAKh .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-PeO7OzQbzLpXRAKh .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-PeO7OzQbzLpXRAKh .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-PeO7OzQbzLpXRAKh .marker{fill:#333333;stroke:#333333;}#mermaid-svg-PeO7OzQbzLpXRAKh .marker.cross{stroke:#333333;}#mermaid-svg-PeO7OzQbzLpXRAKh svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-PeO7OzQbzLpXRAKh p{margin:0;}#mermaid-svg-PeO7OzQbzLpXRAKh .label{font-family:"trebuchet ms",verdana,arial,sans-serif;color:#333;}#mermaid-svg-PeO7OzQbzLpXRAKh .cluster-label text{fill:#333;}#mermaid-svg-PeO7OzQbzLpXRAKh .cluster-label span{color:#333;}#mermaid-svg-PeO7OzQbzLpXRAKh .cluster-label span p{background-color:transparent;}#mermaid-svg-PeO7OzQbzLpXRAKh .label text,#mermaid-svg-PeO7OzQbzLpXRAKh span{fill:#333;color:#333;}#mermaid-svg-PeO7OzQbzLpXRAKh .node rect,#mermaid-svg-PeO7OzQbzLpXRAKh .node circle,#mermaid-svg-PeO7OzQbzLpXRAKh .node ellipse,#mermaid-svg-PeO7OzQbzLpXRAKh .node polygon,#mermaid-svg-PeO7OzQbzLpXRAKh .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-PeO7OzQbzLpXRAKh .rough-node .label text,#mermaid-svg-PeO7OzQbzLpXRAKh .node .label text,#mermaid-svg-PeO7OzQbzLpXRAKh .image-shape .label,#mermaid-svg-PeO7OzQbzLpXRAKh .icon-shape .label{text-anchor:middle;}#mermaid-svg-PeO7OzQbzLpXRAKh .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-PeO7OzQbzLpXRAKh .rough-node .label,#mermaid-svg-PeO7OzQbzLpXRAKh .node .label,#mermaid-svg-PeO7OzQbzLpXRAKh .image-shape .label,#mermaid-svg-PeO7OzQbzLpXRAKh .icon-shape .label{text-align:center;}#mermaid-svg-PeO7OzQbzLpXRAKh .node.clickable{cursor:pointer;}#mermaid-svg-PeO7OzQbzLpXRAKh .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-PeO7OzQbzLpXRAKh .arrowheadPath{fill:#333333;}#mermaid-svg-PeO7OzQbzLpXRAKh .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-PeO7OzQbzLpXRAKh .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-PeO7OzQbzLpXRAKh .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-PeO7OzQbzLpXRAKh .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-PeO7OzQbzLpXRAKh .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-PeO7OzQbzLpXRAKh .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-PeO7OzQbzLpXRAKh .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-PeO7OzQbzLpXRAKh .cluster text{fill:#333;}#mermaid-svg-PeO7OzQbzLpXRAKh .cluster span{color:#333;}#mermaid-svg-PeO7OzQbzLpXRAKh div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-PeO7OzQbzLpXRAKh .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-PeO7OzQbzLpXRAKh rect.text{fill:none;stroke-width:0;}#mermaid-svg-PeO7OzQbzLpXRAKh .icon-shape,#mermaid-svg-PeO7OzQbzLpXRAKh .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-PeO7OzQbzLpXRAKh .icon-shape p,#mermaid-svg-PeO7OzQbzLpXRAKh .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-PeO7OzQbzLpXRAKh .icon-shape .label rect,#mermaid-svg-PeO7OzQbzLpXRAKh .image-shape .label rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-PeO7OzQbzLpXRAKh .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-PeO7OzQbzLpXRAKh .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-PeO7OzQbzLpXRAKh :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;} push_back 新元素
拷贝构造一份副本
vector 扩容
搬迁全部已有元素
erase 中间元素
后续元素逐个赋值前移
sort 与 remove
大量赋值与交换
容器内保存的是独立的值
拷贝必须正确
拷贝必须尽量便宜
📖 图解 :图里四条路径分别对应容器最常发生的复制:
push_back会拷贝构造新元素;vector扩容会把全部旧元素搬到新缓冲区;erase中间元素会让后面的元素逐个赋值前移;sort、remove、unique会通过赋值或交换重排元素。四条路径最后汇合到同一个结论------容器里存的是"独立的值",所以拷贝的正确性和成本会渗透到每一次操作。看这张图时请特别注意:复制不只发生在"插入"那一刻,删除和排序同样在复制,很多性能问题就藏在这些不显眼的地方。
🎯 为什么这很重要?
容器不"引用"你的对象,它"拥有"一份副本。 你执行 v.push_back(w),容器里出现的不是 w 本身,而是 w 的拷贝;之后你修改 w,容器里的那份不受影响,反过来也一样。这个设计不是标准委员会偷懒,而是值语义带来的好处:每个元素有独立的生命周期,容器可以自由搬移、排序、删除,不必担心外部对象什么时候析构。但代价也很直接------所有操作都要为"复制"买单。如果你的类型拷贝一次要读 10 MB 文件、要查数据库、要复制一块大缓冲区,那么容器每扩容一次,就是在重复这些昂贵动作;如果你的类型拷贝语义是错的,容器每复制一次,就在制造一个 bug。
先把"复制发生点"盘点清楚。 很多人只想到插入,其实删除和排序同样在复制:
| 操作 | 复制/赋值发生在哪里 | 备注 |
|---|---|---|
push_back/insert |
拷贝构造新元素 | 传临时对象时可能多一次拷贝(现代可用移动消除) |
vector 扩容 |
把旧元素搬到新缓冲区 | 没有 reserve 时会反复发生 |
erase 中间元素 |
后续元素逐个赋值前移 | 删一个元素可能赋值 O(n) 次 |
sort/remove/unique |
赋值或交换元素 | remove 只搬移,不真正删除 |
| 按值传参/返回 | 拷贝构造 | 大对象传 const& 可避免 |
| 查找/计数 | 通常按 const& 比较 |
一般不比拷贝贵,但比较函数可能有成本 |
这张表说明:"插入时才复制"是一种错觉 。尤其 erase 和 remove,它们看起来是"删除",底层却是在赋值;如果对象的 operator= 很贵,删除一批元素的成本可能远超你的想象。理解这一点,才能理解为什么书里反复强调"容器的复制要廉价"。
"廉价"不是口号,是会乘法放大的成本。 假设每个元素拷贝一次要 1 MB 内存复制,容器里有一万个元素:一次扩容就要搬 10 GB 数据,而这还可能只是多次扩容中的一次。真实项目里常见的场景是:一个 std::vector<BigObject> 在循环里 push_back,没有 reserve,每次容量翻倍都把旧元素全部深拷贝一遍;程序看起来只是"加载慢",实际上是拷贝次数太多。修法往往很朴素:reserve 一次分配、把大对象换成 shared_ptr(拷贝只加引用计数)、或者干脆让对象本身变轻(少存裸数据,多存 std::string 这类会管理资源的成员)。优化的第一步不是换容器,而是让"复制"这件事本身变便宜。
"正确"比"廉价"更要命。 最常见的错误是浅拷贝:类里有一个裸指针成员,构造时 new 一块内存,析构时 delete,但没写拷贝构造和拷贝赋值。编译器生成的默认拷贝只复制指针的值,于是容器里的元素和源对象指向同一块内存。临时对象一析构,容器里的指针就悬垂;容器再析构,同一块内存被二次释放------程序可能在毫无关系的地方崩溃。C++ 管这个叫"三法则"(Rule of Three):如果你需要自定义析构函数、拷贝构造函数、拷贝赋值运算符中的任何一个,通常三个都需要。现代 C++ 再加上移动构造和移动赋值,就变成"五法则";核心思想没变:资源的所有权语义必须由你自己写清楚,不能交给默认的逐成员复制。
第二个经典错误是切片(slicing)。 你写 std::vector<Base> v; v.push_back(Derived());,本意是"存一个派生类对象",实际发生的是:Derived 对象被拷贝构造为 Base 子对象,派生类特有的成员和虚表指针都留在原地,没进容器。此后 v[0] 的静态类型和动态类型都是 Base,虚函数调用只会走 Base::f()。这不是"多态失效"这么抽象,而是"你以为存了 Sprite,实际存了一个被切掉半边身子的 Base"。需要运行时多态时,容器里应该存 shared_ptr<Base> 或 unique_ptr<Base>,让指针指向完整的派生对象;如果只是值语义的数据,就别用继承来表达,改用组合或独立类型。
还有一类问题:拷贝"正确"但"不该发生"。 有些对象的拷贝会带来副作用:拷贝构造时把自己注册进全局表、增加实例计数、打开文件、加锁。把这种对象按值放进容器,容器每次扩容都在偷偷注册一遍、计数加一、打开一个文件。更极端的是持有 std::mutex 的对象------它根本不可拷贝,容器的 push_back 会直接编译失败。前者是逻辑 bug,后者是编译错误;两者都在提醒你:不是所有对象都适合按值进容器。 不可拷贝的对象可以存指针/智能指针;拷贝有副作用的对象应该重新设计拷贝语义,或者明确禁止拷贝。
删除和排序的成本,常常被低估。 vector/deque 删除中间元素时,后面的元素要逐个赋值前移;如果你在循环里一个一个 erase,复杂度会变成 O(n²) 次赋值,而每一次赋值都可能是深拷贝。正确姿势是用区间 erase 或 erase-remove 惯用法,一次搬移完成(条款 05 会详细讲)。list 的成员 remove/unique 只改指针、不做元素赋值,这也是它在"删除密集"场景下的真正优势。sort 则会大量交换元素,如果交换依赖深拷贝,排序会慢得离谱;现代 C++ 的移动语义能缓解,但书成书的 2001 年还没有右值引用,那时的 sort 就是实打实的拷贝/赋值。
现代 C++ 的移动语义改变了什么? C++11 引入了右值引用和移动构造:vector 扩容时,如果元素的移动构造是 noexcept 的,标准库会优先移动而不是拷贝;push_back(std::move(x))、emplace_back(...) 可以避免一次临时对象拷贝。这些确实让"昂贵对象进容器"变得可行。但要注意三点:第一,移动不是万能的,erase 中间元素仍然是逐个移动/赋值,成本还在;第二,移动后的对象处于"有效但未指定"的状态,不能假设它还是原值;第三,书里的结论是基于 C++98 的拷贝语义写的,现代读者要把"拷贝"部分理解成"拷贝或移动",但"正确性"的要求一点没变。移动构造写错(比如移动后源对象仍持有资源),同样会制造二次释放。
设计上的建议:让容器存"轻"的东西。 首选内置类型、std::string、std::shared_ptr 这类拷贝便宜且正确的类型;如果业务对象很大,就在容器里存 shared_ptr<BigObject>,让"复制容器元素"变成"复制一个指针 + 加引用计数"。但要注意,shared_ptr 带来共享所有权语义:修改一个元素会影响所有持有者,这不是"值语义"了。如果你需要值语义又想要便宜拷贝,可以用写时复制(copy-on-write)或不可变对象,但这些都要自己实现,别指望标准库替你决定。最忌讳的是:为了"拷贝便宜"而写浅拷贝,把正确性卖掉------那不是优化,是把 bug 藏得更深。
还有一个容易忽略的点:拷贝构造和拷贝赋值的成本可能不一样。 容器扩容用的是拷贝构造(或移动构造),erase 中间元素用的是拷贝赋值(或移动赋值),sort 两者都可能用。你优化了拷贝构造,不代表赋值也便宜;反过来也一样。给类型做性能优化时,两个函数都要看,别只测 push_back 就下结论。更稳妥的做法是:在调试构建里给两个函数各加一个计数器,跑一遍真实流程,看看到底是"构造多"还是"赋值多",再决定优化谁。
一个生活化比喻。 容器像一家复印店:你递进去一份文件,它复印一份存档。如果文件只是几页纸,复印很快;如果文件是一个装着 10 GB 数据的保险箱,复印机会把数据全部复制一遍,每来一次都要等半天。更糟的是,如果文件里夹着一把钥匙,而复印机只会复印"钥匙的位置",你就会得到两个保险箱共用一把钥匙------一个被销毁,另一个就打不开了。"廉价"说的是别拿 10 GB 的保险箱来复印;"正确"说的是复印时别把钥匙的归属搞错。
最后一条实践准则:把"可拷贝且拷贝正确"当成类型进入容器的门槛。 在设计类型时先问三个问题:拷贝一次要做什么?拷贝后两个对象是否真正独立?如果拷贝很贵,能不能改成存指针/智能指针?这三个问题答不清楚,就先别把它放进容器。容器不会替你修复拷贝语义,它只会把拷贝语义的后果放大到每一次插入、删除和排序。
🔬 关键代码
cpp
// ❌ 浅拷贝:默认拷贝只复制指针,两个对象共指一块堆内存
class BadWidget {
public:
explicit BadWidget(const std::string& name)
: buf(new char[name.size() + 1]) {
std::strcpy(buf, name.c_str());
}
~BadWidget() { delete[] buf; }
// 没有自定义拷贝构造/赋值 → 编译器逐成员复制指针
private:
char* buf;
};
std::vector<BadWidget> v;
v.push_back(BadWidget("hello")); // 临时对象与容器元素共指同一 buf
// 临时对象析构 delete[] → 容器元素悬垂;容器析构再 delete[] → 二次释放 💥
// ✅ 修法一:让成员自己管理资源,拷贝天然正确
class GoodWidget {
public:
explicit GoodWidget(const std::string& name) : data(name) {}
private:
std::string data; // string 自己会深拷贝,正确且相对廉价
};
// ✅ 修法二:如果必须持有裸资源,就按"三法则"补齐
// 拷贝构造(复制资源)、拷贝赋值(释放旧资源 + 复制 + 自赋值安全)、析构
cpp
// ❌ 切片:vector<Base> 只能保存 Base 子对象
class Base {
public:
virtual ~Base() = default;
virtual void draw() const;
};
class Sprite : public Base {
public:
void draw() const override;
};
std::vector<Base> v;
v.push_back(Sprite()); // Sprite 特有的部分被切掉,动态类型退化为 Base
v[0].draw(); // 调用 Base::draw,多态丢失
// ✅ 需要多态:容器存智能指针,指向完整的派生对象
std::vector<std::shared_ptr<Base>> v2;
v2.push_back(std::make_shared<Sprite>());
cpp
// 仅示意:数一数"复制"到底发生了多少次
struct Counted {
static int copies;
Counted() {}
Counted(const Counted&) { ++copies; }
Counted& operator=(const Counted&) { ++copies; return *this; }
};
int Counted::copies = 0;
std::vector<Counted> a;
for (int i = 0; i < 1000; ++i) a.push_back(Counted()); // 无 reserve,多次扩容
int withoutReserve = Counted::copies;
Counted::copies = 0;
std::vector<Counted> b;
b.reserve(1000); // 一次分配
for (int i = 0; i < 1000; ++i) b.push_back(Counted());
int withReserve = Counted::copies;
// 具体次数依实现而定,但"无 reserve 的拷贝次数明显更多"是稳定结论
代码里的
Counted只是一个计数器,用来说明"复制次数"是可以被观测的。真实项目里更实用的做法是:给大对象加一个拷贝计数(仅调试构建),跑一遍核心流程,你会被扩容时的复制量吓到------然后就会自觉写reserve了。
⚠️ 常见坑与对策
| 坑 | 现象 | 对策 |
|---|---|---|
| 类里有裸指针却不写拷贝构造/赋值 | 容器元素与源对象共指一块内存;析构时二次释放或悬垂 | 按三法则/五法则补齐;或改用 std::string/智能指针等 RAII 成员 |
用 vector<Base> 存派生类对象 |
对象被切片,虚函数调用退回基类版本 | 存 shared_ptr<Base>/unique_ptr<Base>,或改用组合 |
大对象按值进容器且不 reserve |
每次扩容深拷贝全部元素,加载/插入极慢 | 先 reserve;再考虑存 shared_ptr 或让对象变轻 |
在循环里逐个 erase 中间元素 |
O(n²) 次赋值/移动,删除一批元素卡死 | 用区间 erase 或 erase-remove(条款 05/09) |
| 拷贝构造有注册、计数、开文件等副作用 | 容器扩容时副作用重复发生,逻辑错乱 | 重新设计拷贝语义;或禁止拷贝、改存指针 |
对象含 std::mutex 等不可拷贝成员 |
push_back 直接编译失败 |
存 shared_ptr,或把锁移出被拷贝的值对象 |
| 以为移动语义能消除所有拷贝 | erase/sort 仍有大量移动,移动后源对象状态未指定 |
理解移动的边界;不要读取已移动对象,也不要依赖"零拷贝" |
这张表可以浓缩成一句话:容器只负责放大你的拷贝语义,不负责修正它。 拷贝便宜且正确,容器就是顺风车;拷贝昂贵或错误,容器就是放大器。
🧠 记住这一条
- ✅ 容器存的是值的副本,插入、扩容、删除、排序都在复制/赋值。
- ✅ 让拷贝便宜:优先轻量类型、
std::string、智能指针,并用reserve减少扩容。 - ✅ 让拷贝正确:资源所有权自己管,遵守三法则/五法则,别依赖默认浅拷贝。
- ❌ 不要往基类对象容器里塞派生类对象,会切片。
- ❌ 不要为了"拷贝便宜"而写浅拷贝;那不是优化,是把 bug 藏得更深。
📎 延伸阅读

📚 来源 :Effective STL, Item 03
🏷️ 标签 :
Effective STLItem 03值语义拷贝成本