Alias de tipo, plantilla de alias (desde C++11)

#include <string>
#include <ios>
#include <type_traits>
 
// alias de tipo, lo mismo que
// typedef std::ios_base::fmtflags flags;
using flags = std::ios_base::fmtflags;
// el nombre 'flags' indica ahora un tipo:
flags fl = std::ios_base::dec;
 
// alias de tipo, igual a
// typedef void (*func)(int, int);
using func = void (*) (int, int);
// el nombre 'func' indica ahora un puntero a función:
void example(int, int) {}
func f = example;
 
// plantilla de alias
template<class T>
using ptr = T*; 
// el nombre 'ptr<T>' ahora es un alias de puntero a T
ptr<int> x;
 
// alias de tipo usado para ocultar un parámetro de plantilla
template<class CharT>
using mystring = std::basic_string<CharT, std::char_traits<CharT> >;
mystring<char> str;
 
// el alias de tipo puede introducir un nombre typedef de miembro
template<typename T>
struct Container { using value_type = T; };
// que se puede usar en programación general
template<typename ContainerType>
void g(const ContainerType& c) { typename ContainerType::value_type n; }
 
// alias de tipo usado para simplificar la sintaxis de std::enable_if
template<typename T>
using Invoke = typename T::type;
template<typename Condition>
using EnableIf = Invoke<std::enable_if<Condition::value> >;
template<typename T, typename = EnableIf<std::is_polymorphic<T> > >
int fpoly_only(T t) { return 1; }
 
struct S { virtual ~S() {} };
 
int main() 
{
    Container<int> c;
    g(c); // Container::value_type será int en esta función
//  fpoly_only(c); // error: enable_if no permite sto
    S s;
    fpoly_only(s); // correcto: enable_if permite esto
}