0

我正在尝试根据模板参数是原始类型还是容器来创建具有不同行为的模板类。基本上，如果模板参数是一个容器，我希望对容器进行 push_back 操作，但如果它是原始类型，我希望类分配给它。有关所需行为的示例，请参见下面的 main。

这是我尝试完成这项工作的尝试，但在尝试了各种方法后我无法编译它。谁能告诉我这里出了什么问题？谢谢！

尝试 1

#include <vector>

template<typename V>
struct store_to
{
    static void call(V& d, V const& v)
    {
        d = v;
    }
};

template<typename V, template<typename> class C>
struct store_to< C<V> >
{
    static void call(C<V>& d, V const& val)
    {
        d.push_back(val);
    }
};

template<typename V>
struct get_element_type
{
    typedef V value_type;
};

template<typename V, template<typename> class C>
struct get_element_type< C<V> >
{
    typedef typename C<V>::value_type value_type;
};

template<class T>
class holder
{
public:
    typedef T value_type;
    typedef typename get_element_type<T>::value_type element_type;

    holder() { }
    ~holder() { }

    void store(element_type const& value)
    { store_to<T>::call(_data, value); }

    void store_default()
    { store_to<T>::call(_data, _default_value); }

    void set_default(element_type const& value)
    { _default_value = value; }

    const value_type& data() const
    { return _data; }

    const element_type& default_value() const
    { return _default_value; }

private:
    value_type _data;
    element_type _default_value;
};

int main()
{
    holder<int> x;
    x.set_default(1);
    x.store_default(); // e.g. _data = _default_value;
    x.store(5); // e.g. _data = 5;

    holder< std::vector<int> > y;
    y.set_default(5);
    y.store_default(); // e.g. _data.push_back(_default_value);
    y.store(0); // e.g. _data.push_back(0);

    return 0;
}

尝试 2

这是一个适用于 std::list 和 std::vector 的修改，尽管它仍然不像我想要的那样通用。有没有办法让任何具有 push_back 函数和 value_type typedef 的类 C 都可以使用，而无需多次专门化模板？

#include <vector>
#include <list>

template<typename V>
struct store_to
{
    typedef V outer_type;
    typedef V inner_type;

    static void call(outer_type& d, inner_type const& v)
    { d = v; }
};

template<typename V>
struct store_to< std::vector<V> >
{
    typedef typename std::vector<V> outer_type;
    typedef typename outer_type::value_type inner_type;

    static void call(outer_type& d, inner_type const& val)
    { d.push_back(val); }
};

template<typename V>
struct store_to< std::list<V> >
{
    typedef typename std::list<V> outer_type;
    typedef typename outer_type::value_type inner_type;

    static void call(outer_type& d, inner_type const& val)
    { d.push_back(val); }
};

template<class T>
class holder
{
public:
    typedef typename store_to<T>::outer_type outer_type;
    typedef typename store_to<T>::inner_type inner_type;

    holder() { }
    ~holder() { }

    void store(inner_type const& value)
    { store_to<T>::call(_data, value); }

    void store_default()
    { store_to<T>::call(_data, _default_value); }

    void set_default(inner_type const& value)
    { _default_value = value; }

    const outer_type& data() const
    { return _data; }

    const inner_type& default_value() const
    { return _default_value; }

private:
    outer_type _data;
    inner_type _default_value;
};

int main()
{
    holder<int> x;
    x.set_default(1);
    x.store_default(); // e.g. _data = _default_value;
    x.store(5); // e.g. _data = 5;

    holder< std::vector<int> > y;
    y.set_default(5);
    y.store_default(); // e.g. _data.push_back(_default_value);
    y.store(0); // e.g. _data.push_back(0);

    return 0;
}
4

1 回答 1

0

您可以将插入迭代器传递给您的模板，而不是整个容器。当您调用operator =插入迭代器时，它会向容器中添加一个新元素。您将需要包含<iterator>标题，并且有几种不同的类型可用。

std::vector<int> container;
MyTemplateFunction(back_inserter(container));
于 2013-10-08T14:46:35.760 回答