Plantillas de C++ que aceptan solo ciertos tipos

En Java, puede definir una clase genérica que acepte solo tipos que amplíen la clase de su elección, por ejemplo:

public class ObservableList<T extends List> {
  ...
}

Esto se hace usando la palabra clave “extiende”.

¿Hay algún equivalente simple a esta palabra clave en C++?

Esto generalmente no está justificado en C ++, como han señalado otras respuestas aquí. En C++, tendemos a definir tipos genéricos en función de otras restricciones distintas de “hereda de esta clase”. Si realmente quería hacer eso, es muy fácil hacerlo en C++11 y <type_traits>:

#include <type_traits>

template<typename T>
class observable_list {
    static_assert(std::is_base_of<list, T>::value, "T must inherit from list");
    // code here..
};

Sin embargo, esto rompe muchos de los conceptos que la gente espera en C++. Es mejor usar trucos como definir tus propios rasgos. Por ejemplo, tal vez observable_list quiere aceptar cualquier tipo de contenedor que tenga los typedefs const_iterator y un begin y end función miembro que devuelve const_iterator. Si restringe esto a las clases que heredan de list entonces un usuario que tiene su propio tipo que no hereda de list pero proporciona estas funciones miembro y typedefs no podría usar su observable_list.

Hay dos soluciones a este problema, una de ellas es no restringir nada y confiar en el tipo de pato. Una gran desventaja de esta solución es que implica una gran cantidad de errores que pueden ser difíciles de asimilar para los usuarios. Otra solución es definir rasgos para restringir el tipo proporcionado para cumplir con los requisitos de la interfaz. La gran desventaja de esta solución es que implica una escritura adicional que puede verse como molesta. Sin embargo, el lado positivo es que podrá escribir sus propios mensajes de error a la static_assert.

Para completar, se da la solución al ejemplo anterior:

#include <type_traits>

template<typename...>
struct void_ {
    using type = void;
};

template<typename... Args>
using Void = typename void_<Args...>::type;

template<typename T, typename = void>
struct has_const_iterator : std::false_type {};

template<typename T>
struct has_const_iterator<T, Void<typename T::const_iterator>> : std::true_type {};

struct has_begin_end_impl {
    template<typename T, typename Begin = decltype(std::declval<const T&>().begin()),
                         typename End   = decltype(std::declval<const T&>().end())>
    static std::true_type test(int);
    template<typename...>
    static std::false_type test(...);
};

template<typename T>
struct has_begin_end : decltype(has_begin_end_impl::test<T>(0)) {};

template<typename T>
class observable_list {
    static_assert(has_const_iterator<T>::value, "Must have a const_iterator typedef");
    static_assert(has_begin_end<T>::value, "Must have begin and end member functions");
    // code here...
};

Hay muchos conceptos que se muestran en el ejemplo anterior que muestran las características de C++11. Algunos términos de búsqueda para los curiosos son plantillas variádicas, SFINAE, expresión SFINAE y rasgos de tipo.

Sugiero usar Boost afirmación estática característica en concierto con is_base_of de la biblioteca de Rasgos de Tipo de Impulso:

template<typename T>
class ObservableList {
    BOOST_STATIC_ASSERT((is_base_of<List, T>::value)); //Yes, the double parentheses are needed, otherwise the comma will be seen as macro argument separator
    ...
};

En algunos otros casos más simples, puede simplemente declarar una plantilla global, pero solo definirla (especializarla explícita o parcialmente) para los tipos válidos:

template<typename T> class my_template;     // Declare, but don't define

// int is a valid type
template<> class my_template<int> {
    ...
};

// All pointer types are valid
template<typename T> class my_template<T*> {
    ...
};

// All other types are invalid, and will cause linker error messages.

[Minor EDIT 6/12/2013: Using a declared-but-not-defined template will result in linker, not compiler, error messages.]

La solución simple, que nadie ha mencionado todavía, es simplemente ignorar el problema. Si trato de usar un int como un tipo de plantilla en una plantilla de función que espera una clase de contenedor como vector o lista, obtendré un error de compilación. Crudo y simple, pero resuelve el problema. El compilador intentará usar el tipo que especifique y, si falla, generará un error de compilación.

El único problema con eso es que los mensajes de error que reciba serán difíciles de leer. Sin embargo, es una forma muy común de hacer esto. La biblioteca estándar está llena de plantillas de funciones o clases que esperan cierto comportamiento del tipo de plantilla y no hacen nada para comprobar que los tipos utilizados son válidos.

Si desea mensajes de error más agradables (o si desea detectar casos que no producirían un error del compilador, pero que aún no tienen sentido), puede, dependiendo de qué tan complejo quiera hacerlo, usar la afirmación estática de Boost o la biblioteca Boost concept_check.

Con un compilador actualizado, tiene un incorporado static_assertque podría usarse en su lugar.

Nosotros podemos usar std::is_base_of y std::enable_if:
(static_assert pueden eliminarse, las clases anteriores pueden implementarse de forma personalizada o utilizarse desde aumentar si no podemos hacer referencia type_traits)

#include <type_traits>
#include <list>

class Base {};
class Derived: public Base {};

#if 0   // wrapper
template <class T> class MyClass /* where T:Base */ {
private:
    static_assert(std::is_base_of<Base, T>::value, "T is not derived from Base");
    typename std::enable_if<std::is_base_of<Base, T>::value, T>::type inner;
};
#elif 0 // base class
template <class T> class MyClass: /* where T:Base */
    protected std::enable_if<std::is_base_of<Base, T>::value, T>::type {
private:
    static_assert(std::is_base_of<Base, T>::value, "T is not derived from Base");
};
#elif 1 // list-of
template <class T> class MyClass /* where T:list<Base> */ {
    static_assert(std::is_base_of<Base, typename T::value_type>::value , "T::value_type is not derived from Base");
    typedef typename std::enable_if<std::is_base_of<Base, typename T::value_type>::value, T>::type base; 
    typedef typename std::enable_if<std::is_base_of<Base, typename T::value_type>::value, T>::type::value_type value_type;

};
#endif

int main() {
#if 0   // wrapper or base-class
    MyClass<Derived> derived;
    MyClass<Base> base;
//  error:
    MyClass<int> wrong;
#elif 1 // list-of
    MyClass<std::list<Derived>> derived;
    MyClass<std::list<Base>> base;
//  error:
    MyClass<std::list<int>> wrong;
#endif
//  all of the static_asserts if not commented out
//  or "error: no type named ‘type’ in ‘struct std::enable_if<false, ...>’ pointing to:
//  1. inner
//  2. MyClass
//  3. base + value_type
}

Por lo que sé, esto no es posible actualmente en C++. Sin embargo, hay planes para agregar una función llamada “conceptos” en el nuevo estándar C++0x que proporciona la funcionalidad que está buscando. Esta artículo de wikipedia about C++ Concepts lo explicará con más detalle.

Sé que esto no soluciona su problema inmediato, pero hay algunos compiladores de C++ que ya comenzaron a agregar funciones del nuevo estándar, por lo que es posible encontrar un compilador que ya haya implementado la función de conceptos.

Un equivalente que solo acepta tipos T derivados del tipo List parece

template<typename T, 
         typename std::enable_if<std::is_base_of<List, T>::value>::type* = nullptr>
class ObservableList
{
    // ...
};

Creo que todas las respuestas anteriores han perdido de vista el bosque por los árboles.

genéricos de Java no son lo mismo que las plantillas; ellos usan borrado de tipoel cual es un técnica dinámicaen vez de polimorfismo en tiempo de compilacióncual es técnica estática. Debería ser obvio por qué estas dos tácticas tan diferentes no funcionan bien.

En lugar de intentar usar una construcción de tiempo de compilación para simular una de tiempo de ejecución, veamos qué extends realmente lo hace: según Stack Overflow y Wikipediaextends se usa para indicar subclases.

C++ también admite subclases.

También muestra una clase de contenedor, que utiliza el borrado de tipo en forma de genérico, y se extiende para realizar una verificación de tipo. En C++, debe hacer la maquinaria de borrado de tipos usted mismo, lo cual es simple: haga un puntero a la superclase.

Envolvámoslo en un typedef, para que sea más fácil de usar, en lugar de hacer una clase completa, et voila:

typedef std::list<superclass*> subclasses_of_superclass_only_list;

Por ejemplo:

class Shape { };
class Triangle : public Shape { };

typedef std::list<Shape*> only_shapes_list;
only_shapes_list shapes;

shapes.push_back(new Triangle()); // Works, triangle is kind of shape
shapes.push_back(new int(30)); // Error, int's are not shapes

Ahora, parece que List es una interfaz que representa una especie de colección. Una interfaz en C++ sería simplemente una clase abstracta, es decir, una clase que implementa nada más que métodos virtuales puros. Con este método, puede implementar fácilmente su ejemplo de Java en C++, sin ningún concepto o especialización de plantilla. También funcionaría tan lento como los genéricos de estilo Java debido a las búsquedas de tablas virtuales, pero esto a menudo puede ser una pérdida aceptable.