Perché non è necessario utilizzare typename per tipi dipendenti nel seguente caso?

Ho letto sulla rimozione del riferimento di un tipo, qui .

Dà il seguente esempio:

#include <iostream> // std::cout
#include <type_traits> // std::is_same

template<class T1, class T2>
void print_is_same() {
  std::cout << std::is_same<T1, T2>() << '\n';
}

int main() {
  std::cout << std::boolalpha;

  print_is_same<int, int>();
  print_is_same<int, int &>();
  print_is_same<int, int &&>();

  print_is_same<int, std::remove_reference<int>::type>(); // Why not typename std::remove_reference<int>::type ?
  print_is_same<int, std::remove_reference<int &>::type>();// Why not typename std::remove_reference<int &>::type ?
  print_is_same<int, std::remove_reference<int &&>::type>();// Why not typename std::remove_reference<int &&>::type ?
}

Le types nei std::remove_referencetratti sono tipi dipendenti.

Possibile implementazione

template< class T > struct remove_reference      {typedef T type;};
template< class T > struct remove_reference<T&>  {typedef T type;};
template< class T > struct remove_reference<T&&> {typedef T type;};

Ma perché non lo usa typename std::remove_reference</*TYPE*/>::type?

Le types nei std::remove_referencetratti sono tipi dipendenti.

No, non sono nomi dipendenti qui. Gli argomenti del modello sono stati specificati in modo esplicito come int, int&e int&&. Pertanto, i tipi sono noti a questo punto.

D'altra parte, se si utilizza std::remove_referenceun parametro template, ad es

template <typename T>
void foo() {
    print_is_same<int, typename std::remove_reference<T>::type>();
}

quindi devi usare typenameper dire che std::remove_reference<T>::typeè un tipo dato che la tua espressione ora dipende dal parametro template T.

In poche parole, è necessario typenameassicurarsi che il compilatore

std::remove_reference<int>::type

è davvero un tipo. Consideriamo qualche altro modello

template <typename T>
struct foo {
    using type = int;
};

Ecco foo::typeun tipo. Ma cosa succede se qualcuno fornisce una specializzazione lungo la linea di

template <> struct foo<int> {
    int type;
};

Ora typenon è un tipo ma un int. Ora quando usi foo all'interno di un modello:

template <typanem T> 
struct bar {
    using type = typename foo<T>::type;
};

Devi assicurarti che il compilatore foo<T>::typesia davvero un tipo, non qualcos'altro, perché solo guardando bar(e il modello principale foo) il compilatore non può saperlo.

Tuttavia, nel tuo mainthe std::remove_reference<int>::typenon dipende da un parametro template, quindi il compilatore può facilmente verificare se è un tipo.

La parola chiave typename viene utilizzata per aiutare il compilatore ad analizzare l'origine. Indica che l'id è un nome di tipo, non un nome di variabile o nome di metodo. Ma in situazioni come sopra il compilatore può capirlo da solo, quindi questa parola chiave non è richiesta.