Изменение value_type данного контейнера STL

Question

Предположим, у меня есть контейнер STL тип (не объект), скажем vector<A>.Теперь value_type равно A, поэтому я хочу изменить его на B.

По сути, я хочу шаблон класса этой формы или его вариант:

template<typename container, typename new_value_type>
struct change_value_type
{
    typedef /*....*/  new_container;
};

, чтобы я мог использовать его следующим образом:

typename change_value_type<vector<A>, B>::new_container  vectorOfB; 
vectorOfB.push_back(B());
vectorOfB.push_back(B());
vectorOfB.push_back(B());
//etc

Значит, new_container - это vector<B>

Возможно ли это?

Answer 1

Вы можете попробовать специализироваться с параметрами шаблона шаблона.

#include <vector>
#include <list>
#include <deque>
#include <string>

template <class T, class NewType>
struct rebind_sequence_container;

template <class ValueT, class Alloc, template <class, class> class Container, class NewType>
struct rebind_sequence_container<Container<ValueT, Alloc>, NewType >
{
     typedef Container<NewType, typename Alloc::template rebind<NewType>::other > type;
};

template <class Container, class NewType>
void test(const NewType& n)
{
    typename rebind_sequence_container<Container, NewType>::type c;
    c.push_back(n);
}

int main()
{
    std::string s;
    test<std::vector<int> >(s);
    test<std::list<int> >(s);
    test<std::deque<int> >(s);
}

Однако контейнеры могут не иметь этих двух параметров шаблона.

Кроме того, в контейнерах-адаптерах и ассоциативных контейнерах требуется замена не только распределителя (базовый контейнер в адаптерах, предикат вstd::set).ОТО, их использование настолько отличается от последовательных контейнеров, что трудно представить шаблон, который работает с любым типом контейнера.

Answer 2

Просто наткнулся на это, когда я пытался по существу решить ту же проблему.Можно даже заставить работать без , полагаясь на тип rebind, специфичный для std::allocator - единственное требование состоит в том, что тип значения отскока является первым параметром шаблона соответствующих классов.Это относится ко всем соответствующим классам STL (std::vector, std::set, std::list и т. Д., А также, например, std::less и std::allocator).

A до C ++ 11Решение будет выглядеть так:

template <class Container, class NewType>
struct rebind;

template <class ValueType, template <class> class Container, class NewType>
struct rebind<Container<ValueType>, NewType>
{
  typedef Container<NewType> type;
};

template <class ValueType, class A, template <class, class> class Container, class NewType>
struct rebind<Container<ValueType, A>, NewType>
{
  typedef Container<NewType, typename rebind<A, ValueType>::type> type;
};

template <class ValueType, class A, class B, template <class, class, class> class Container, class NewType>
struct rebind<Container<ValueType, A, B>, NewType>
{
  typedef Container<NewType, typename rebind<A, ValueType>::type, typename rebind<B, ValueType>::type> type;
};

// Continue for more parameters (A, B, C, ...)

C ++ 11 делает его немного проще:

template <class Container, class NewType>
struct rebind;

template <class ValueType, class... Args, template <class...> class Container, class NewType>
struct rebind<Container<ValueType, Args...>, NewType>
{
  typedef Container<NewType, typename rebind<Args, NewType>::type...> type;
};

Для поддержки std::array можно добавить следующее:

template <class ValueType, std::size_t N, template <class, std::size_t> class Container, class NewType>
struct rebind<Container<ValueType, N>, NewType>
{
  typedef Container<NewType, N> type;
};

Результат может быть использован практически с любым типом STL:

#include <iostream>
#include <typeinfo>
#include <vector>
#include <set>
#include <deque>
#include <queue>
#include <list>
#include <array>

#include "rebind.h"

// Make it all a bit more compact
#define REBIND_DEMO(container, new_type)                \
  do {                                                  \
    container test;                                     \
    rebind<decltype(test), new_type>::type test2;       \
    std::cout << typeid(test).name() << "\n";           \
    std::cout << typeid(test2).name() << "\n";          \
  } while (0)

int main()
{
  REBIND_DEMO(std::set<float>, double);
  REBIND_DEMO(std::list<float>, double);
  REBIND_DEMO(std::deque<float>, double);
  REBIND_DEMO(std::queue<float>, double);
  typedef std::array<float, 4> TestArray;
  REBIND_DEMO(TestArray, double);
  REBIND_DEMO(std::unordered_set<float>, double);

  return 0;
}

Выполнение этого и передача вывода через c++filt -t в системе Linux дает вам

std::set<float, std::less<float>, std::allocator<float> >
std::set<double, std::less<double>, std::allocator<double> >
std::list<float, std::allocator<float> >
std::list<double, std::allocator<double> >
std::deque<float, std::allocator<float> >
std::deque<double, std::allocator<double> >
std::queue<float, std::deque<float, std::allocator<float> > >
std::queue<double, std::deque<double, std::allocator<double> > >
std::array<float, 4ul>
std::array<double, 4ul>
std::unordered_set<float, std::hash<float>, std::equal_to<float>, std::allocator<float> >
std::unordered_set<double, std::hash<double>, std::equal_to<double>, std::allocator<double> >

Answer 3

Вы ссылаетесь (я полагаю) на идиому Клона политики , используя перепривязку