C++拷贝构造函数调用时机解析与高效实现指南

1次阅读

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

最近在优化一个日志处理系统时，发现当 std::vector<LogEntry> 扩容时，每个 LogEntry 对象都被完整拷贝了 3 次！这让我意识到很多 C ++ 开发者（包括我自己）对拷贝构造函数的隐式调用场景缺乏系统认知。特别是在处理含有文件句柄、网络连接等资源的类时，不当的拷贝行为轻则导致性能下降，重则引发资源重复释放的崩溃。

函数值传递

void process(LogEntry entry);  // 调用时触发拷贝构造

函数返回对象

LogEntry createEntry() {
  LogEntry entry;
  return entry;  // 可能触发 NRVO 优化
}

容器操作

std::vector<LogEntry> logs;
logs.push_back(entry);  // 扩容时触发拷贝

初始化同类对象

LogEntry newEntry = oldEntry;  // 直接调用拷贝构造

异常抛出捕获

throw LogEntry(error);  // 异常对象拷贝

非 POD 类型聚合初始化

struct Wrapper {LogEntry e;};
Wrapper w1{entry}, w2 = w1;  // 触发嵌套拷贝

class FileHandle {
public:
  FileHandle(const char* path) : fd(open(path)) {}
  ~FileHandle() { if(fd != -1) close(fd); }

  // 明确禁用拷贝
  FileHandle(const FileHandle&) = delete;
  FileHandle& operator=(const FileHandle&) = delete;

  // 启用移动语义
  FileHandle(FileHandle&& other) noexcept 
    : fd(other.fd) {other.fd = -1;}

private:
  int fd = -1;
};

std::vector<LogEntry> mergeLogs(std::vector<LogEntry>&& tmpLogs) {

  std::vector<LogEntry> results;
  results.reserve(tmpLogs.size());

  for(auto& log : tmpLogs) {results.push_back(std::move(log)); // 移动而非拷贝
  }
  return results; // 触发 NRVO
}

LogEntry createEntry(int id) {LogEntry entry(id);  // 直接构造在调用处内存
  entry.loadContent();
  return entry;  // 无拷贝发生
}

// 验证汇编输出：-fno-elide-constructors

template<typename... Args>
auto makeLogEntry(Args&&... args) {return LogEntry(std::forward<Args>(args)...);
}

多线程安全
拷贝构造函数中访问共享资源需加锁
移动构造建议标记 noexcept 避免容器扩容时回退到拷贝

继承体系

class Base {
public:
  Base(const Base&) {/*...*/}  // 需显式调用基类拷贝构造
};

class Derived : public Base {
public:
  Derived(const Derived& other) 
    : Base(other) {/* 派生类成员拷贝 */}
};

// benchmark_copy_vs_move.cpp
#include <vector>
#include <chrono>

struct HeavyObject {HeavyObject() = default;
  HeavyObject(const HeavyObject&) {/* 模拟耗时操作 */} 
  HeavyObject(HeavyObject&&) noexcept = default;
};

void test_copy() {std::vector<HeavyObject> v(1'000'000);
  auto start = std::chrono::high_resolution_clock::now();
  auto v2 = v;  // 触发拷贝
  auto dur = std::chrono::high_resolution_clock::now() - start;
  std::cout << "Copy:" << dur.count() << "ns\n";}

void test_move() {std::vector<HeavyObject> v(1'000'000);
  auto start = std::chrono::high_resolution_clock::now();
  auto v2 = std::move(v);  // 触发移动
  auto dur = std::chrono::high_resolution_clock::now() - start;
  std::cout << "Move:" << dur.count() << "ns\n";}

/*
测试结果(g++ -O2):
Copy: 125,789,456ns
Move: 1,245ns
*/

C++20 概念约束

template<typename T>
concept Copyable = requires(T a) {{ T(a) } -> std::same_as<T>;  // 验证可拷贝性
};

template<Copyable T>
void safeCopy(T obj);  // 确保类型安全