[C++] Restringere tipo template (come Java: <T extends Base>)

[biowep]

Ciao, so che non esiste un modo diretto per poter restringere il tipo che un parametro di un template può diventare. Quello che volevo chiedere è come ci si comporta in questi casi?
Voglio dire, io in java posso definire:
class Classe<T extends Base>{}
Dentro quella classe so che posso sicuramente (senza preoccuparmi di nulla), dato un attributo o una variabile di tipo T chiamare tutti i membri di Base. Certamente se poi vorrò qualcosa in più dovrò verificare il tipo e fare un casting.

In C++ si fa il casting normalmente o si chiamano metodi dati per scontato senza preoccuparsi di quale tipo sia il template? Considerato che il compilatore a volte da informazioni completamente generiche sull'errore commesso e quindi chi userà quel determinato codice potrebbe non capire.

[WarDuck]

Potresti usare le static_assertion di C++11 insieme ai type traits:


#include <iostream>
#include <type_traits>

class Base
{
public:
virtual void hello() = 0;
};

class Specific : public Base
{
public:
virtual void hello() {
printf("Hello World!\n");
}
};

class Another {
void hello() {
}
};

template<class T>
class Wrapper
{
T object;

public:

Wrapper() {
static_assert(std::is_base_of<Base, T>::value, "T must be a Base type");
}

void hello() {

object.hello();
}
};

int main(void)
{
Wrapper<Another> w; // non compila (se usi Wrapper<Specific> compila)

w.hello();

return 0;
}


Output con Wrapper<Another>:

example.cc: In instantiation of ‘Wrapper<T>::Wrapper() [with T = Another]’:
example.cc:44:22: required from here
example.cc:33:9: error: static assertion failed: T must be a Base type

[biowep]

Molto interessante, ma rispetto a static_cast, è di molto più inefficiente?
Inoltre, static_assert sarebbe un costrutto del linguaggio che permette di generare un qualsiasi errore nel compilatore in base ad una condizione oppure è pensato per altro?

Grazie per l'aiuto.

[WarDuck]

Molto interessante, ma rispetto a static_cast, è di molto più inefficiente?
Inoltre, static_assert sarebbe un costrutto del linguaggio che permette di generare un qualsiasi errore nel compilatore in base ad una condizione oppure è pensato per altro?

Grazie per l'aiuto.

Quello che ho riportato sopra è il metodo più sicuro (type safe) in quanto se passi un oggetto che non ha quella classe base non compila ;).

static_assert è una asserzione a compile time, ma la condizione dev'essere appunto verificabile a tempo di compilazione (in C++11 hanno anche introdotto la keyword constexpr che ti può aiutare nel costruire espressioni valutabili a tempo di compilazione).

In realtà anche static_cast dovrebbe fare dei controlli sul tipo a tempo di compilazione (sicuramente più che quelli del cast C classico), però dal mio punto di vista quella sopra è una soluzione più "elegante" :D.