Qual é a diferença entre 'typedef' e 'using' no C ++ 11?

Eu sei que no C ++ 11 agora podemos usar usingpara escrever alias de tipo, como typedefs:

typedef int MyInt;

É, pelo que entendi, equivalente a:

using MyInt = int;

E essa nova sintaxe surgiu do esforço de ter uma maneira de expressar " template typedef":

template< class T > using MyType = AnotherType< T, MyAllocatorType >;

Mas, com os dois primeiros exemplos não-modelo, existem outras diferenças sutis no padrão? Por exemplo, typedefs faz alias de maneira "fraca". Ou seja, ele não cria um novo tipo, mas apenas um novo nome (as conversões estão implícitas entre esses nomes).

É o mesmo com usingou gera um novo tipo? Existem diferenças?

Eles são equivalentes, do padrão (ênfase minha) (7.1.3.2):

Um typedef-name também pode ser introduzido por uma declaração de alias. O identificador que segue a palavra-chave using se torna um typedef-name e o atributo-specifier-seq opcional após o identificador pertence a esse typedef-name. Tem a mesma semântica como se tivesse sido introduzida pelo especificador typedef. Em particular, ele não define um novo tipo e não deve aparecer no ID do tipo.

Eles são basicamente os mesmos, exceto que:

A declaração de alias é compatível com modelos, enquanto o estilo C typedef não é.

A sintaxe de uso tem uma vantagem quando usada em modelos. Se você precisar do tipo abstração, mas também precisar manter o parâmetro do modelo para poder ser especificado no futuro. Você deve escrever algo assim.

template <typename T> struct whatever {};

template <typename T> struct rebind
{
  typedef whatever<T> type; // to make it possible to substitue the whatever in future.
};

rebind<int>::type variable;

template <typename U> struct bar { typename rebind<U>::type _var_member; }

Mas o uso da sintaxe simplifica esse caso de uso.

template <typename T> using my_type = whatever<T>;

my_type<int> variable;
template <typename U> struct baz { my_type<U> _var_member; }

Eles são essencialmente os mesmos, mas usingfornece o alias templatesque é bastante útil. Um bom exemplo que pude encontrar é o seguinte:

namespace std {
 template<typename T> using add_const_t = typename add_const<T>::type;
}

Então, podemos usar em std::add_const_t<T>vez detypename std::add_const<T>::type

Sei que o pôster original tem uma ótima resposta, mas para qualquer um que tropeçar nesse tópico como eu, há uma nota importante da proposta que, em minha opinião, agrega algo de valor à discussão aqui, principalmente às preocupações nos comentários sobre se a typedefpalavra-chave é será marcado como obsoleto no futuro ou removido por ser redundante / antigo:

Foi sugerido (re) usar a palavra-chave typedef ... para introduzir aliases de modelo:

template<class T>
  typedef std::vector<T, MyAllocator<T> > Vec;

Essa notação tem a vantagem de usar uma palavra-chave já conhecida por introduzir um alias de tipo. No entanto, ele também exibe várias desvantagens [sic], entre as quais a confusão de usar uma palavra-chave conhecida por introduzir um alias para um nome de tipo em um contexto em que o alias não designa um tipo, mas um modelo; nãoVec é um alias para um tipo e não deve ser usado como um typedef-name. O nome é um nome para a família - onde o marcador é um espaço reservado para um nome de tipo. Posteriormente, não propomos a sintaxe “typedef”. Por outro lado, a fraseVecstd::vector<•, MyAllocator<•> >

template<class T>
  using Vec = std::vector<T, MyAllocator<T> >;

pode ser lido / interpretado como: a partir de agora, usarei Vec<T>como sinônimostd::vector<T, MyAllocator<T> > . Com essa leitura, a nova sintaxe para alias parece razoavelmente lógica.

Para mim, isso implica suporte contínuo para a typedefpalavra - chave em C ++, pois ainda pode tornar o código mais legível e compreensível .

A atualização da usingpalavra - chave foi especificamente para modelos e (como indicado na resposta aceita) quando você trabalha com não modelos usinge typedefé mecanicamente idêntico, portanto, a escolha depende totalmente do programador com base na legibilidade e na comunicação da intenção. .

Ambas as palavras-chave são equivalentes, mas existem algumas ressalvas. Uma é que declarar um ponteiro de função com using T = int (*)(int, int);é mais claro do que com typedef int (*T)(int, int);. O segundo é que o formulário de alias de modelo não é possível com typedef. Terceiro, é necessário expor a API C typedefem cabeçalhos públicos.

As declarações Typedef podem, enquanto as declarações de alias não, podem ser usadas como instruções de inicialização

Mas, com os dois primeiros exemplos não-modelo, existem outras diferenças sutis no padrão?

Embora seja um caso de canto, uma declaração typedef é uma instrução init e, portanto, pode ser usada em contextos que permitem instruções de inicialização

// C++11 (C++03) (init. statement in for loop iteration statements).
for(typedef int Foo; Foo{} != 0;) {}

// C++17 (if and switch initialization statements).
if (typedef int Foo; true) { (void)Foo{}; }
//  ^^^^^^^^^^^^^^^ init-statement

switch(typedef int Foo; 0) { case 0: (void)Foo{}; }
//     ^^^^^^^^^^^^^^^ init-statement

// C++20 (range-based for loop initialization statements).
std::vector<int> v{1, 2, 3};
for(typedef int Foo; Foo f : v) { (void)f; }
//  ^^^^^^^^^^^^^^^ init-statement

Considerando que uma declaração de alias não é uma instrução init e , portanto, não pode ser usada em contextos que permitem instruções de inicialização

// C++ 11.
for(using Foo = int; Foo{} != 0;) {}
//  ^^^^^^^^^^^^^^^ error: expected expression

// C++17 (initialization expressions in switch and if statements).
if (using Foo = int; true) { (void)Foo{}; }
//  ^^^^^^^^^^^^^^^ error: expected expression

switch(using Foo = int; 0) { case 0: (void)Foo{}; }
//     ^^^^^^^^^^^^^^^ error: expected expression

// C++20 (range-based for loop initialization statements).
std::vector<int> v{1, 2, 3};
for(using Foo = int; Foo f : v) { (void)f; }
//  ^^^^^^^^^^^^^^^ error: expected expression