如何让std::set支持可变元素？规避std::map的冗余与数据不一致问题

我希望std::set能够存储可变（非const）元素，但std::set仅提供const元素访问，是否有可行的解决办法？

原因如下：我定义了如下类：

struct Cow
{
    Cow(const std::string &name)
      : name(name)
      , age (0)
        {}

    void Moo()
      { std::cout << name << " is mooing." << std::endl; }

    const std::string name;
    int               age ;
};

我希望将该类的元素存储在std::set中，元素通过其始终为const的name字段标识，但同时需要对非const方法（如Moo()）和成员（如age）进行可变访问。

我可以改用std::map存储，但不想将name与对象分离存储（name是对象的一部分）；也可以重复存储name，一个作为std::map的键，另一个保存在对象内，但这会造成内存浪费，还可能出现键与对象内name不一致的数据问题。

请问该如何解决？

针对你的场景，有三种可靠的解决思路，核心都是保证不修改影响std::set排序的键（即name字段）——std::set的const限制本质是为了维护内部有序结构的稳定性，只要不破坏排序逻辑，就可以安全地实现可变访问。

方法1：使用const_cast解除非键成员的const限制 #

既然name是const且不会被修改，你可以安全地用const_cast将std::set返回的const引用转为非const引用，从而修改age或调用非const成员函数：

#include <set>
#include <iostream>
#include <string>

struct Cow
{
    Cow(const std::string &name)
      : name(name)
      , age (0)
        {}

    void Moo()
      { std::cout << name << " is mooing." << std::endl; }

    const std::string name;
    int               age ;
};

// 自定义比较器，基于name排序
struct CompareCow {
    bool operator()(const Cow& a, const Cow& b) const {
        return a.name < b.name;
    }
};

int main() {
    std::set<Cow, CompareCow> cow_set;
    cow_set.emplace("Bessie");
    cow_set.emplace("Daisy");

    // 获取元素并修改age、调用Moo()
    auto it = cow_set.find("Bessie");
    if (it != cow_set.end()) {
        Cow& non_const_cow = const_cast<Cow&>(*it);
        non_const_cow.age = 3;
        non_const_cow.Moo(); // 输出：Bessie is mooing.
    }

    return 0;
}

⚠️ 绝对不能用这种方式修改name字段，否则会破坏std::set的内部有序结构，导致未定义行为。

方法2：用mutable修饰非键成员，调整const成员函数 #

如果你的非const成员函数（如Moo()）实际上不需要修改对象的键字段，可以将其改为const成员函数；同时将需要修改的非键成员（如age）声明为mutable，这样即使是const对象也能修改这些成员：

#include <set>
#include <iostream>
#include <string>

struct Cow
{
    Cow(const std::string &name)
      : name(name)
      , age (0)
        {}

    // 将Moo()改为const成员函数
    void Moo() const
      { std::cout << name << " is mooing." << std::endl; }

    const std::string name;
    mutable int age ; // 用mutable修饰age，允许在const上下文中修改
};

struct CompareCow {
    bool operator()(const Cow& a, const Cow& b) const {
        return a.name < b.name;
    }
};

int main() {
    std::set<Cow, CompareCow> cow_set;
    cow_set.emplace("Bessie");

    auto it = cow_set.find("Bessie");
    if (it != cow_set.end()) {
        it->age = 3; // 直接修改mutable成员，无需const_cast
        it->Moo(); // 调用const成员函数
    }

    return 0;
}

这种方法更符合C++的const语义，适合不需要调用非const成员函数的场景。

方法3：存储智能指针到std::set #

如果需要保留对象的完全可变性（包括调用非const成员函数），可以让std::set存储智能指针（如std::unique_ptr或std::shared_ptr），此时std::set的const限制仅作用于指针本身，而指针指向的对象是非const的：

#include <set>
#include <iostream>
#include <string>
#include <memory>

struct Cow
{
    Cow(const std::string &name)
      : name(name)
      , age (0)
        {}

    void Moo()
      { std::cout << name << " is mooing." << std::endl; }

    const std::string name;
    int               age ;
};

// 自定义比较器，基于指针指向的Cow的name排序
struct CompareCowPtr {
    bool operator()(const std::unique_ptr<Cow>& a, const std::unique_ptr<Cow>& b) const {
        return a->name < b->name;
    }
};

int main() {
    std::set<std::unique_ptr<Cow>, CompareCowPtr> cow_set;
    cow_set.insert(std::make_unique<Cow>("Bessie"));
    cow_set.insert(std::make_unique<Cow>("Daisy"));

    // 手动遍历查找并修改对象（避免find的临时对象匹配问题）
    for (auto& ptr : cow_set) {
        if (ptr->name == "Bessie") {
            ptr->age = 3;
            ptr->Moo();
            break;
        }
    }

    return 0;
}

⚠️ 使用指针时必须自定义比较器，确保std::set基于对象的name而非指针地址排序；若使用std::unique_ptr，直接调用find需要构造临时对象，手动遍历会更直观。

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