c+中集合/容器的接口/超类+； 我来自java世界，正在构建一个小型C++程序。 我有一个对象，它做一些工作，然后以列表的形式返回工作的结果

一天后，我改变了对象的行为，将结果保存在一个集合中，以避免容器中出现重复。但是我不能简单地返回集合，因为我第一次使用了接口列表。 是否有一个通用的容器接口，我可以使用它来指定对象的接口，而不必考虑我在内部使用的容器类型

目前，我正在创建一个集合，添加所有值，然后从集合中创建一个列表：

return std::list<foo>(this->mySet.begin(), this->mySet.end())

return std:：list（this->mySet.begin（），this->mySet.end（））

---

看起来有点奇怪。

与Java不同，整个C++标准库（包括其容器）不是基于接口（继承、多态），而是基于模板（为了效率）

您可以围绕集合创建一个多态包装器，但这不是C++的方式

最简单的解决方案就是使用一些类型别名简化程序：

#include <iostream>
#include <list>
#include <vector>

using namespace std;

class Test {

private:
    typedef vector<int> Collection;

    Collection c;

public:

    typedef Collection::const_iterator It;

    void insert(int Item) {
        c.push_back(Item);
    }

    It begin() const { return c.begin(); }
    It end()   const { return c.end(); }

};

int main() {

    Test foo;

    foo.insert(23);
    foo.insert(40);

    for (Test::It i = foo.begin(); i != foo.end(); ++i)
        cout << *i << endl;

    return 0;
}

#包括
#包括
#包括
使用名称空间std；
课堂测试{
私人：
typedef向量集合；
c组；
公众：
typedef集合：：const_迭代器；
空白插入（整数项）{
c、 推回（项目）；
}
它的begin（）常量{返回c.begin（）；}
It end（）常量{返回c.end（）；}
};
int main（）{
测试食品；
foo.插入（23）；
foo.插入（40）；
for（Test:：It i=foo.begin（）；i！=foo.end（）；++i）
从你的描述来看，我认为简短的回答是否定的

通常，当我创建这样的集合形式时，我通常会使用typedef来指定我使用的容器：

class Object {
   typedef std::list<int> Cont;
   typedef Cont::iterator iterator;
   typedef Cont::const_iterator const_iterator;

   // ....
};

类对象{
typedef std：：列表Cont；
typedef Cont:：迭代器迭代器；
typedef Cont:：const_迭代器const_迭代器；
// ....
};

所有客户机代码都引用“Object:：Cont”等，因此只要客户机只使用容器的一般功能，如果容器发生更改，它们就不需要更改

如果您现在无法更改API，那么我认为您的解决方案相当不错，但是，根据您拥有的数据，如果您进行了大量倾向于唯一的插入，那么继续使用列表并仅在最后删除重复项可能会更有效：

void foo (std::list<int> & list) {

  // ... fill the list

  list.sort ();
  list.unique (); 
}

void foo（标准：：列表和列表）{
//…填写清单
list.sort（）；
list.unique（）；
}
不存在接口。相反，您通常会使用模板，并简单地说“我不在乎它是什么类型，只要它表现为一个容器”

假设您的函数如下所示：

std::list<int> DoStuff()

template <typename container_type>
void caller() {
  container_type result = DoStuff();
}

std:：list DoStuff（）

可以这样称呼：

std::list<int> DoStuff()

template <typename container_type>
void caller() {
  container_type result = DoStuff();
}

模板
void caller（）{
容器类型结果=DoStuff（）；
}

如果您决定返回一个
集合
，则只需更改第一个函数。调用函数并不真正关心（当然，只要您不依赖列表的细节）

如果您发布更多的示例代码，我们可以更好地建议如何在C++中完成。
< P>容器的概念由迭代器填充。
正如您所看到的，硬编码特定类型的容器可能不是您想要的。因此，让您的类返回迭代器。然后您可以重新使用Conatinters迭代器

class MyClass
{
    private:
        typedef  std::list<int>            Container;
    public:
        typedef  Container::iterator       iterator;
        typedef  Container::const_iterator const_iterator; 


        iterator        begin()        {return myData.begin();}
        const_iterator  begin() const  {return myData.begin();}

        iterator        end()          {return myData.end();}
        const_iterator  end()   const  {return myData.end();}

    private:
        Container   myData;
};

class-MyClass
{
私人：
typedef std：：列表容器；
公众：
typedef容器：：迭代器迭代器；
typedef容器：：常量迭代器常量迭代器；
迭代器begin（）{返回myData.begin（）；}
const_迭代器begin（）const{return myData.begin（）；}
迭代器end（）{return myData.end（）；}
const_迭代器end（）const{return myData.end（）；}
私人：
容器myData；
};

现在，当您将容器类型从std:：list更改为std:：set时，没有人需要知道。

另外，通过使用其他容器使用的标准名称，您的类开始看起来像STL中的任何其他容器

注意：返回常量迭代器的方法应该是常量方法