Эффективный и современный С++. 42 рекомендации по использованию С++11 и С++14 - [29]

// MyAllocList является синонимом для std::list>:
template
 using MyAllocList = std::list>;

MyAllocList lw; // Клиентский код

В случае typedef эти семечки приходится сначала долго растить:

// MyAllocList::type - синоним для std::list>:
template
struct MyAllocList {
 typedef std::list> type;
};

MyAllocList::type lw; // Клиентский код

Все еще хуже. Если вы хотите использовать typedef в шаблоне для создания связанного списка, хранящего объекты типа, указанного параметром шаблона, имя, указанное в typedef, следует предварять ключевым словом typename:

template
class Widget {                       // Widget содержит
private:                             // MyAllocList,
 typename MyAllocList::type list; // как член-данные
};

Здесь MyAllocList::type ссылается на тип, который зависит от параметра типа шаблона (T). Тем самым MyAllocList::type является зависимым типом (dependent type), а одно из многих милых правил С++ требует, чтобы имена зависимых типов предварялись ключевым словом typename.

Если MyAllocList определен как шаблон псевдонима, это требование использования ключевого слова typename убирается (как и громоздкий суффикс “::type”):

template
using MyAllocList = std::list>; // Как и ранее

template
class Widget {
private:
 MyAllocList list;                         // Ни typename,
                                              // ни ::type
};

Для вас MyAllocList (т.e. использование шаблона псевдонима) может выглядеть как зависимый от параметра шаблона T, как и MyAllocList::type (т.e. как и использование вложенного typedef), но вы не компилятор. Когда компилятор обрабатывает шаблон Widget и встречает использование MyAllocList (т.e. использование шаблона псевдонима), он знает, что MyAllocList является именем типа, поскольку MyAllocList является шаблоном псевдонима: он обязан быть именем типа. Тем самым MyAllocList оказывается независимым типом, и спецификатор typename не является ни требуемым, ни разрешенным.

С другой стороны, когда компилятор видит MyAllocList::type (т.e. использование вложенных typedef) в шаблоне Widget, он не может знать наверняка, что эта конструкция именует тип, поскольку это может быть специализация MyAllocList, с которой он еще не встречался и в которой MyAllocList::type ссылается на нечто, отличное от типа. Это звучит глупо, но не вините компиляторы за то, что они рассматривают такую возможность. В конце концов, это люди пишут такой код.

Например, некая заблудшая душа вполне в состоянии написать следующее:

class Wine { … };

template<>                // Специализация MyAllocList в
class MyAllocList { // которой T представляет собой Wine
private:
 enum class WineType      // См. в разделе 3.4 информацию об
 { White, Red, Rose };    // "enum class"

 WineType type;           // В этом классе type представляет
                          // собой данные-член!
};

Как видите, MyAllocList::type не является типом. Если Widget инстанцирован с Wine, MyAllocList::type в шаблоне Widget представляет собой данные-член, а не тип. Ссылается ли MyAllocList::type на тип в шаблоне Widget, зависит от того, чем является T, а потому компиляторы требуют, чтобы вы точно указывали, что это тип, предваряя его ключевым словом typename.

Если вы занимаетесь метапрограммированием с использованием шаблонов (template metaprogramming — ТМР), то вы, скорее всего, сталкивались с необходимостью получать параметры типов шаблонов и создавать из них новые типы. Например, для некоторого заданного типа T вы можете захотеть удалить квалификатор const или квалификатор ссылки, содержащийся в T, например преобразовать const std::string& в std::string. Вы можете также захотеть добавить const к типу или преобразовать его в lvalue-ссылку, например, превращая Widget в const Widget или в Widget&. (Если вы еще не занимались ТМР, это плохо, потому что, если вы действительно хотите быть эффективным программистом на С++, вы должны быть знакомы как минимум с основами этого аспекта С++. Вы можете увидеть примеры ТМР в действии, включая различные преобразования типов, о которых я упоминал, в разделах 5.1 и 5.5.)

С++11 дает вам инструменты для такого рода преобразований в виде свойств типов (type traits), набора шаблонов в заголовочном файле . В нем вы найдете десятки свойств типов; не все из них выполняют преобразования типов, но те, которые это делают, предлагают предсказуемый интерфейс. Для заданного типа T, к которому вы хотели бы применить преобразование, результирующий тип имеет вид std::преобразование::type, например:

std::remove_const::type         // Дает T из const T
std::remove_reference::type     // Дает T из T& и T&&
std::add_lvalue_reference::type // Дает T& из T

Комментарии просто резюмируют, что делают эти преобразования, так что не принимайте их слишком буквально. Перед тем как использовать их в своем проекте, я настоятельно советую ознакомиться с их точной спецификацией.