Plantillas y STL

Question

El siguiente código representa un contenedor basado en std :: vector

template <typename Item> 
struct TList 
{ 
    typedef std::vector <Item> Type; 
}; 


template <typename Item> 
class List 
{ 
private 
      typename TList <Item>::Type items; 
    .... 
} 

int main() 
{ 
    List <Object> list; 
} 

¿Es posible crear plantillas de std :: vector y crear un contenedor en general, algo por el estilo?

template <typename Item, typename stl_container> 
struct TList 
{ 
    typedef stl_container<Item>; 
}; 

donde stl_container representa std :: vector, std :: list, std :: set ...? Me gustaría elegir el tipo de contenedor en el momento de la creación.

List <Object, std::vector> list; //vector of objects, not a real code 
List <Object, std::vector> list; //list of objects, not a real code 

Gracias por sus respuestas ...

pregunta Actualizado:

He probado el siguiente código pero hay errores:

#include <vector> 
template <typename Item, typename Container> 
struct TList 
{ 
    typedef typename Container <Item>::type type; //Error C2059: syntax error : '<', Error C2238: unexpected token(s) preceding '; 
}; 


template <typename T> 
struct vector_container 
{ 
    typedef std::vector<T> type; 
}; 

int _tmain(int argc, _TCHAR* argv[]) 
{ 
TList <int, vector_container> v; 
TList <int, map_container> m; 
} 

Answer 1

sí y no.

puede utilizar un parámetro de plantilla plantilla, por ejemplo,

template <typename Item, template <typename> class Container> 
struct TList { /* ... */ }; 

Sin embargo, en general, los parámetros de plantilla plantilla no son particularmente útiles debido a que el número y los tipos de los parámetros de plantilla tienen que coincidir. Por lo tanto, lo anterior no coincidiría std::vector ya que en realidad tiene dos parámetros de plantilla: una para el tipo de valor y otro para el asignador. Un parámetro de plantilla de plantilla no puede aprovechar ningún argumento de plantilla predeterminado.

Para poder utilizar la plantilla std::vector como argumento, TList tendría que ser declarado como:

template <typename Item, template <typename, typename> class Container> 
struct TList { /* ... */ }; 

Sin embargo, con esta plantilla, no sería capaz de utilizar la plantilla como un std::map argumento, ya que tiene cuatro parámetros de plantilla: los tipos de clave y valor, el tipo de imputación, y el tipo de comparación.

Por lo general, es mucho más fácil evitar los parámetros de plantilla plantilla debido a esta falta de flexibilidad.

Answer 2

¿Es posible templamentar std :: vector y crear un contenedor general, algo así?

No. Usted tendría que crear plantillas de la función u objeto utilizando el contenedor - no se podía crear plantillas del propio recipiente.

Por ejemplo. considerar un típico std::find:

template<class InputIterator, class T> 
InputIterator find (InputIterator first, InputIterator last, const T& value) 
{ 
    for (;first!=last; first++) if (*first==value) break; 
    return first; 
} 

Esto funciona para cualquier recipiente, pero no necesita una tempalte con el contenedor en absoluto.

Además, dado que parece que lo que está tratando de hacer es crear un código contenedor independiente, puede comprar o pedir prestado una copia de Scott Meyers' Effective STL y leer el Artículo 2: Cuidado con la ilusión de código independiente del contenedor.

Answer 3

así, puede cortarlo con una macro:

template <typename T, typename stl_container = std::vector<T> > 
struct TList 
{ 
    typedef stl_container Type; 
}; 

#define TLIST(T, C) TList<T, C<T> > 

TList<int> foo; 
TList<int, std::list<int> > bar; 
TLIST(int, std::list) baz; 

Answer 4

Sí, pero no directamente:

template <typename Item, template <typename> class Container> 
struct TList 
{ 
    typedef typename Container<Item>::type type; 
}; 

Entonces podrá definir diferentes políticas de contenedores:

template <typename T> 
struct vector_container 
{ 
    typedef std::vector<T> type; 
}; 

template <typename T> 
struct map_container 
{ 
    typedef std::map<T, std::string> type; 
}; 

TList<int, vector_container> v; 
TList<int, map_container> m; 

Un poco detallado, sin embargo. * Para hacer las cosas directamente, necesitarías tomar the route described by James, pero como él nota esto es en última instancia muy inflexible.

Sin embargo, con C++ 0x podemos hacer esto muy bien:

#include <map> 
#include <vector> 

template <typename Item, 
      template <typename...> class Container, typename... Args> 
struct TList 
{ 
    // Args lets the user specify additional explicit template arguments 
    Container<Item, Args...> storage; 
}; 

int main() 
{ 
    TList<int, std::vector> v; 
    TList<int, std::map, float> m; 
} 

perfecto. Desafortunadamente no hay forma de reproducir esto en C++ 03, excepto que a través de las clases de directivas de indirección se presentan como se describió anteriormente.

---

* Quiero hacer hincapié en que por "Un poco prolijo" quiero decir "esto es poco ortodoxo". La solución correcta para su problema es lo que hace la biblioteca estándar, as Jerry explains. Que acaba de dejar al usuario de su adaptador de contenedores especificar todo el tipo de contenedor directamente:

template <typename Item, typename Container = std::vector<Item>> 
struct TList 
{}; 

Pero esto deja un gran problema: ¿qué pasa si no quiero el tipo de valor de que el contenedor sea Item pero something_else<Item>? En otras palabras, ¿cómo puedo cambiar el tipo de valor de un contenedor existente a otra cosa? En su caso, no es así, no siga leyendo, pero en el caso que lo hagamos, queremos volver a vincular un contenedor.

Por desgracia para nosotros, los contenedores no tienen esta funcionalidad, aunque asignadores hacen:

template <typename T> 
struct allocator 
{ 
    template <typename U> 
    struct rebind 
    { 
     typedef allocator<U> type; 
    }; 

    // ... 
}; 

Esto nos permite obtener una allocator<U> dieron un allocator<T>. ¿Cómo podemos hacer lo mismo con los contenedores sin esta utilidad intrusiva? En C++ 0x, es fácil:

template <typename T, typename Container> 
struct rebind; // not defined 

template <typename T, typename Container, typename... Args> 
struct rebind<T, Container<Args...>> 
{ 
    // assumes the rest are filled with defaults** 
    typedef Container<T> type; 
}; 

Dado std::vector<int>, podemos realizar rebind<float, std::vector<int>>::type, por ejemplo. A diferencia del anterior C++ 0x solución, ésta puede ser emulado en C++ con las macros y 03 iteración ..

---

** Nota Este mecanismo se puede hacer mucho más potente, como especificar qué argumentos para mantener , que volver a enlazar, que volver a enlazar antes de usar como argumentos, etc., pero eso se deja como un ejercicio para el lector. :)

Answer 5

Estoy un poco confundido por qué algunas personas muy inteligentes (y competentes) dicen que no.

A menos que haya leído mal su pregunta, lo que está tratando de lograr es prácticamente idéntico a los "adaptadores de contenedor" en la biblioteca estándar. Cada uno proporciona una interfaz para algún tipo de contenedor subyacente, con el tipo de contenedor que se usará como un parámetro de plantilla (con un valor predeterminado).

Por ejemplo, un std::stack utiliza algún otro contenedor (p. Ej., std::deque, std::list o std::vector) para contener los objetos, y std::stack solo proporciona una interfaz simplificada/restringida para cuando solo quiere usar operaciones de pila. El contenedor subyacente que será utilizado por std::stack se proporciona como un parámetro de plantilla. Así es como el código se ve en la norma:

namespace std { 
    template <class T, class Container = deque<T> > 
    class stack { 
    public: 
     typedef typename Container::value_type value_type; 
     typedef typename Container::size_type size_type; 
     typedef Container      container_type; 
    protected: 
     Container c; 
    public: 
     explicit stack(const Container& = Container()); 
     bool empty() const    { return c.empty(); } 
     size_type size() const   { return c.size(); } 
     value_type& top()    { return c.back(); } 
     const value_type& top() const { return c.back(); } 
     void push(const value_type& x) { c.push_back(x); } 
     void pop()      { c.pop_back(); } 
    }; 
} 

Por supuesto, tal vez he apenas entendido mal la pregunta - si es así, pido disculpas de antemano a las personas con las que estoy (más o menos) en desacuerdo.

Answer 6

Puede usar los parámetros de plantilla de plantilla como otros han mencionado aquí. La dificultad principal con esto no es que los tipos de contenedor diferentes tengan parámetros de plantilla diferentes, sino que el estándar permite que los contenedores estándar, como vector, tengan parámetros de plantilla además de los necesarios documentados.

Usted puede evitar esto al proporcionar sus propios tipos de subclases que aceptan los parámetros de plantilla adecuados y dejar que cualquier accesorio (que han de tener valores por defecto) se llenarán en mi la ejecución:

template < typename T > struct simple_vector : std::vector<T> {}; 

O puede utilizar el idioma de typedef con plantilla:

template < typename T > struct retrieve_vector { typedef std::vector<T> type; };