7

我正在寻找一种将元素添加到 STL 容器背面的通用方法。我希望代码支持尽可能多类型的 STL 容器。下面的一段代码演示了我的问题：

#include <vector>
#include <string>

using namespace std;

template<typename T>
class S {
  T built;
  typename T::iterator built_it;
public:
  S() : built{}, built_it{built.end()} {}
  void add_to(typename T::value_type e) {
    built.emplace(built_it, e);
    ++built_it;
  }
  const T& get() {
    return built;
  }
};

int main()
{ 
  S<std::vector<int>> e;
  S<std::string> f;
  e.add_to(3);   // works
  f.add_to('c'); // doesn't
}

这里的问题很微妙。这段代码对vectors 很有效，因为std::vector它实现了emplace函数。但std::string没有！有没有更通用的方法来执行相同的操作？

4

3 回答 3

10

最通用的方式（不一定是最有效的方式）是：

c.insert( c.end(), value );

当然，其中value需要适合容器c（您可以使用decltype(c)::value_type）。在关联容器的情况下，例如map，它是std::pair.

这适用于除std::forward_list. 对于某些容器，元素会在最后添加，对于某些容器，这c.end()只是一个可能被忽略的提示。

作为评论的后续，这里是高级的东西；）

当您想将已知数量的元素插入给定容器c（类型为C）并且希望至少有点效率时，您应该检测容器类型是否支持reserve()并在插入元素之前调用它。

以下方法检测reserve()正确（链接说明如何）：

template< typename C, typename = void >
struct has_reserve
  : std::false_type
{};

template< typename C >
struct has_reserve< C, std::enable_if_t<
                         std::is_same<
                           decltype( std::declval<C>().reserve( std::declval<typename C::size_type>() ) ),
                           void
                         >::value
                       > >
  : std::true_type
{};

现在您可以使用它std::enable_if_t来选择性地保留空间。一个示例可能如下所示：

template< typename C >
std::enable_if_t< !has_reserve< C >::value >
optional_reserve( C&, std::size_t ) {}

template< typename C >
std::enable_if_t< has_reserve< C >::value >
optional_reserve( C& c, std::size_t n )
{
  c.reserve( c.size() + n );
}

template< typename C, typename T, std::size_t N >
void add_array( C& c, const std::array< T, N >& a )
{
  optional_reserve( c, N );
  for( const auto& e : a ) {
    c.insert( c.end(), typename C::value_type( e ) ); // see remark below
  }
}

add_array现在可以使用所有标准容器（除了）调用它，std::forward_list它将调用无序关联容器。reserve()std::vector

由于上述方法不需要对特定容器类型进行显式特化或重载，因此它也适用于非标准容器，只要它们的接口设计合理地类似于标准容器的接口即可。（事实上​​我过去有几个这样的“自制”容器和上面的 Just-Works™）

A remark about the conversion in the above code: The reason for converting the Ts to C::value_type is just to show that this would be the correct place if it is needed. In the above example it might look superfluous, but in my real-world code I call a special conversion traits class to convert the es (which are encoded strings) into the correct value type for any container.

于 2013-10-15T23:07:24.263 回答
5

大多数情况下，人们使用特征。

许多 boost 库都解决了同样的问题，因此您也许可以重用现有的特征。

一个简单的演示：住在 Coliru

#include <vector>
#include <set>
#include <string>

namespace traits
{
    template <typename Container, typename Enable = void>
        struct add_at_end;

    template <typename... TAs>
        struct add_at_end<std::vector<TAs...> > 
        {
            using Container = std::vector<TAs...>;

            template <typename... CtorArgs>
            static void apply(Container& container, CtorArgs&&... args) {
                container.emplace_back(std::forward<CtorArgs>(args)...);
            }
        };

    template <typename... TAs>
        struct add_at_end<std::set<TAs...> > 
        {
            using Container = std::set<TAs...>;

            template <typename... CtorArgs>
            static void apply(Container& container, CtorArgs&&... args) {
                container.insert(container.end(), { std::forward<CtorArgs>(args)...});
            }
        };

    template <typename... TAs>
        struct add_at_end<std::basic_string<TAs...> > 
        {
            using Container = std::basic_string<TAs...>;

            template <typename... CtorArgs>
            static void apply(Container& container, CtorArgs&&... args) {
                container.insert(container.end(), { std::forward<CtorArgs>(args)...});
            }
        };
}

template <typename Container, typename... CtorArgs>
    void add_to(Container& container, CtorArgs&&... args) {
        traits::add_at_end<Container>::apply(container, std::forward<CtorArgs>(args)...);
    }

int main()
{
    using X = std::pair<int, std::string>;

    std::vector<X> v;
    std::set<X>    s;
    std::wstring   wstr;
    std::string    str;

    add_to(v, 12, "hello");
    add_to(s, 42, "world");
    add_to(wstr, L'!');
    add_to(str, '?');
}

基本上，您所做的是拥有一个独立的实用程序函数add_to，该函数使用traits::add_at_end可以专门化的特征类（在这种情况下，适用于任何vector<...>、set<...>或basic_string<...>模板实例。

在实践中，您可以通过继承通用实现来共享类似容器（例如deque和）的实现。vector

于 2013-10-15T22:51:44.647 回答
2

push_back由std::string、std::vector和支持std::list。有了这个，你的类模板很简单：

template<typename T>
class S {
  T built;
public:
  S() : built{} {}
  void add_to(typename T::value_type e) {
    built.push_back(e);
  }
  const T& get() {
    return built;
  }
};
于 2013-10-15T23:06:59.513 回答