C++ unordered_map使用大型自定义对象作为键的性能优化问询

我正在开发一个C++项目，定义了自定义类作为unordered_map的键，已经重载了==运算符并提供了自定义哈希函数，但执行时发现插入键值对会触发类的拷贝构造函数。如果是包含大量数据的大型对象（比如封装了大型vector<int>的对象），这种拷贝会带来明显的性能开销。

我有Python和Java背景，这两种语言的哈希表存储的是对象引用而非拷贝，所以不确定C里的最佳实践。想知道有没有更高效的方式避免拷贝开销，以及这类场景下的性能优化推荐做法。我自己想到用指针，但刚学C，不确定这是不是最优方案。

#include <iostream>
#include <unordered_map>
#include <functional> 

class MyClass {
private:
    int key;
    std::string value;

public:
    MyClass(int k, const std::string& v) : key(k), value(v) {}

    MyClass(const MyClass& obj) {
        std::cout << "copy constructor called" << std::endl;
        key = obj.key;
        value = obj.value;
    }

    // 重载==运算符
    bool operator==(const MyClass& other) const {
        return (key == other.key && value == other.value);
    }

    // 哈希函数
    friend std::size_t hash_value(const MyClass& obj) {
        std::size_t seed = 0;
        std::hash<int> hasher;
        std::hash<std::string> strHasher;
        seed ^= hasher(obj.key) + 0x9e3779b9 + (seed<<6) + (seed>>2);
        seed ^= strHasher(obj.value) + 0x9e3779b9 + (seed<<6) + (seed>>2);
        return seed;
    }
};

namespace std {
    template <>
    struct hash<MyClass> {
        std::size_t operator()(const MyClass& obj) const {
            return hash_value(obj);
        }
    };
}

int main() {
    std::unordered_map<MyClass, int> map;

    MyClass c1(1, "1");
    MyClass c2(2, "2");
    MyClass c3(1, "1");
    std::cout << "------step 1-------" << std::endl;
    map[c1] = 1;
    map[c2] = 2;
    std::cout << "------step 2-------" << std::endl;
    std::cout << map[c3] << std::endl;
    std::cout << "------step 3-------" << std::endl;
    map[MyClass(5, "5")] = 5;
    std::cout << "------step 4-------" << std::endl;
    std::cout << (map.find(MyClass(4, "4")) != map.end()) << std::endl;
    std::cout << "------step 5-------" << std::endl;
    auto p = std::make_pair(c1, 5);
    std::cout << "------step 6-------" << std::endl;
    map.insert(p);
    return 0;
}

------step 1-------
copy constructor called
copy constructor called
------step 2-------
1
------step 3-------
copy constructor called
------step 4-------
0
------step 5-------
copy constructor called
------step 6-------

1. 启用移动语义（最直接的优化） #

C++11及以后支持移动语义，给你的类添加移动构造函数，这样临时对象或者用std::move转移的对象会被移动而非拷贝，对于包含大型容器（如vector）的类，移动操作只是转移指针，开销极低。

修改MyClass，添加移动构造函数：

// 移动构造函数
MyClass(MyClass&& obj) noexcept {
    std::cout << "move constructor called" << std::endl;
    key = std::move(obj.key);
    value = std::move(obj.value);
}

之后，像map[MyClass(5, "5")] = 5这种临时对象插入时，会触发移动构造而非拷贝；如果是已有对象，可以用std::move转移所有权：

map[std::move(c1)] = 1; // 触发移动构造，而非拷贝

2. 使用emplace直接在容器内构造对象 #

unordered_map的emplace方法可以直接在容器的内存空间里构造键值对，完全避免拷贝或移动（除非构造过程中需要）。

比如替换map[c1] = 1为：

// 直接在map内构造MyClass对象
map.emplace(MyClass(1, "1"), 1);
// 或者用piecewise_construct更高效地构造，避免临时对象
map.emplace(std::piecewise_construct,
            std::forward_as_tuple(1, "1"),
            std::forward_as_tuple(1));

emplace会直接在桶的节点中构造MyClass，不需要先创建对象再拷贝进去。

3. 使用智能指针作为键（适合大型不可变对象） #

如果你想类似Java/Python那样存储引用，可以用std::shared_ptr<MyClass>作为键，但需要注意：默认的std::hash<std::shared_ptr<T>>是基于指针地址的哈希，而不是对象内容，所以需要自定义哈希和相等比较。

示例代码：

// 自定义shared_ptr<MyClass>的哈希
namespace std {
    template <>
    struct hash<std::shared_ptr<MyClass>> {
        std::size_t operator()(const std::shared_ptr<MyClass>& ptr) const {
            return hash_value(*ptr); // 复用之前的对象哈希逻辑
        }
    };
}

// 自定义相等比较（默认的shared_ptr==是比较地址，这里要比较对象内容）
bool operator==(const std::shared_ptr<MyClass>& a, const std::shared_ptr<MyClass>& b) {
    return *a == *b;
}

// 使用方式
std::unordered_map<std::shared_ptr<MyClass>, int> map;
auto ptr = std::make_shared<MyClass>(1, "1");
map[ptr] = 1; // 只拷贝指针，开销极小

注意：用智能指针作为键时，要确保对象内容不会被修改（否则哈希值会变化，导致无法找到键），最好把MyClass设计成不可变类。

4. 提取轻量唯一键（如果可行） #

如果你的大型对象里有一个唯一的轻量标识（比如示例中的int key），可以直接用这个标识作为unordered_map的键，然后把大型对象存在值里，比如：

std::unordered_map<int, std::pair<MyClass, int>> map;
// 插入时
map.emplace(1, std::make_pair(MyClass(1, "1"), 1));

这种方式完全避免了大型对象作为键的拷贝问题，但前提是这个轻量标识必须唯一，否则会出现键冲突。

5. 优化拷贝构造函数（迫不得已时） #

如果必须保留拷贝逻辑，比如需要多个独立的对象实例，可以优化拷贝构造函数，利用std::move转移内部资源，或者改用引用计数的内部存储：

// 比如把成员改成std::shared_ptr<std::vector<int>> data;
// 这样拷贝构造函数只是拷贝指针，开销极小
MyClass(const MyClass& obj) : data(obj.data) {}

内容的提问来源于stack exchange，提问作者maplemaple