自定义对象的 STL 集，每个对象都包含一个 STL 集

Question

从下面的代码中可以清楚地看出，我想要一组对象 objectSet，每个对象包含 str1 和 str2。该集合以 str1 为键，并且不会添加任何已在 objectSet 中具有 str1 的新对象，但如果这个新对象具有不同的 str2，我想跟踪我在 str2Set 中看到它的事实

#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#include <string>
#include <set>
#include <map>

using namespace std;

class Object {
public:
  string _str1;
  string _str2;
  set<string> _str2Set;

  bool operator<(const Object& b) const {
    return _str1 < b._str1;
  }
};

int main(int argc, char *argv[]) {
  set<Object> objectSet;

  Object o;
  o._str1 = "str1";
  o._str2 = "str2";

  pair< set<Object>::iterator, bool> o_ret = objectSet.insert(o);
  if (o_ret.second == false) { // key exists
    int temp = (*o_ret.first)._str2Set.size(); // this is apparently fine
    (*o_ret.first)._str2Set.insert(o._str2); // this results in the error
  }

  return 0;
}

：编译器错误：

set_test.cpp：在函数“int main(int, char**)”中： set_test.cpp:31: 错误：传递 'const std::set, std::allocator >, std::less, std::allocator > >，std::分配器，std::分配器> > >'作为 'std::pair, _Compare, typename _Alloc::rebind<_Key>::other>::const_iterator, bool> 的 'this' 参数std::set<_Key, _Compare, _Alloc>::insert(const _Key&) [其中 _Key = std::basic_string, std::allocator >, _Compare = std::less, std::allocator > >, _Alloc = std::分配器, std::分配器 > >]' 丢弃限定符

我知道这与 const 有关，但我仍然无法确切地弄清楚问题是什么或如何解决它。仅仅摆脱 const 没有帮助。

作为替代方案，我尝试将我的对象存储在 中

map<string,Object> objectSet;

并且，奇怪的是，以下工作正常：

  pair< map<string,Object>::iterator, bool> o_ret = objectSet.insert(pair<string,Object>(o._str1,o));
  if (o_ret.second == false) { // key exists
    o_ret.first->second._str2Set.insert(o._str2);
  }

当然，这意味着我必须存储 str1 两次，我认为这是浪费。 感谢您的意见。

Answer 1

从集合插入返回的迭代器对于该对的第一个成员有一个常量迭代器 - 您不应该修改插入集合中的对象，因为如果修改影响顺序，就会发生不好的事情。所以对它调用 size 是可以的，因为这是一个 const 方法，但是 insert 是不行的，因为它修改了集合中的对象。
映射之所以有效，是因为对象是值，而不是键，因此您可以修改它而不影响映射的索引（在执行映射插入时会复制字符串）。

如果你想使用一个集合来存储你的对象并避免额外的字符串副本，更新它的方法是从集合中删除该对象（在删除它之前制作一个副本），更新副本，然后重新插入复制。当它在集合中时，您无法更新它。我目前没有 STL 参考资料，所以无法给您代码，但这是要遵循的总体思路。

Answer 2

其他答案已经正确说明了您的方法的问题，这是解决方案的想法。由于第一个字符串是您的密钥，因此请将您的主数据结构更改为以第一个字符串为键的 std::map 并携带其余数据作为有效负载：

typedef std::pair< std::string, std::set<std::string> > Payload; // or make your own class
typedef std::map<std::string, Payload>                  Collection;
typedef Collection::value_type                          Data; // this is a std::pair<string, Payload>

// A little helper to create new data objects
Data make_data(std::string s1, std::string s2)
{
  return Data(s1, Payload(s2, std::set<std::string>()));
}

Collection m;

Data x = make_data("mystr1", "mystr2");

std::pair<Collection::iterator, bool> res = m.insert(x);
if (res.second == false)
{
  Payload & p = *res.first;
  p.second.insert(x.second.first);
}

在某种意义上，第二个字符串是有点多余，你也许可以重新设计它以完全消除它：使用 find 代替 insert，如果键已经存在，则附加第二个字符串到集合。

Answer 3

在阅读了每个人的有用评论并学习了比我想象的更多的关于浅层常量和可变的知识之后，我意识到只需存储一个指向 _str2set 的指针就可以完成我想要的一切。我个人认为按照 @john 的建议声明它是可变的很好，但也许有些人会发现 ptr 解决方案不那么令人反感。

class Object {
public:
  string _str1;
  string _str2;
  set<string> * _str2Set;

  bool operator<(const Object& b) const {
    return _str1 < b._str1;
  }
};

int main(int argc, char *argv[]) {
  set<Object> objectSet;

  Object o;
  o._str1 = "str1";
  o._str2 = "str2";
  o._str2Set = new (set<string>);

  pair< set<Object>::iterator, bool> o_ret = objectSet.insert(o);
  if (o_ret.second == false) { // key exists
    (*o_ret.first)._str2Set->insert(o._str2); // this results in the error
    cout << (*o_ret.first)._str2Set->size() << endl;
  }
  return 0;
}

Answer 4

你的设计有缺陷。您正在使用对象作为集合的键，但随后您尝试修改集合的键。当然，您只是修改了对象的部分，不会影响它作为键的使用，但编译器不知道这一点。你需要修改你的设计，你的第二个版本对我来说很好，我不担心存储两次字符串（通常，我不知道你的具体情况）。或者，您可以拆分对象，以便将键部分和值部分分开。最后，您可以将 _str2set 声明为可变的。

Answer 5

该错误表明 (*o_ret.first)._str2Set 是一个 const 对象，并且您无法将其作为对象调用 insert 方法。结果。

这是完全正确的：由于不允许修改 std::set 中的对象（因为这可能会使容器的一致性失效），因此您会得到一个 const 限定的对象将iterator解引用到容器中时对象（就好像它是const_iterator）。

您还注意到它适用于 std::map，但那是因为您正在修改那里的值，而不是键。请记住，在 std::set 中，值是键，因此您无法修改它。