В чем разница между typedef и using в C++? Когда что использовать?

Ключевое различие: шаблонные псевдонимы типов

Главное и самое существенное отличие using от typedef в том, что using поддерживает шаблонные псевдонимы (alias templates), а typedef — нет. Это нововведение C++11, которое решает давнюю проблему.

С typedef вы не можете создать параметризованный псевдоним типа. Ваш пример с вектором не скомпилируется:

// ОШИБКА: typedef не может быть шаблонным
template<typename T>
typedef std::vector<T> Vec;  // ❌ Ошибка компиляции

С using это работает без проблем:

// РАБОТАЕТ: using может быть шаблонным
template<typename T>
using Vec = std::vector<T>;  // ✅ OK

// Использование:
Vec<int> numbers;       // std::vector<int>
Vec<std::string> texts; // std::vector<std::string>

Указатели на функции — читаемость

Второе важное преимущество using — гораздо более читаемый синтаксис для сложных типов, особенно для указателей на функции.

Сравните два объявления одного и того же псевдонима:

// typedef: сложно читать, нужно привыкнуть
typedef void (*FuncPtr)(int, double);

// using: читается слева направо, как присваивание
using FuncPtr = void (*)(int, double);

Для указателей на функции-члены класса разница еще более разительная:

// typedef: кошмар
typedef void (MyClass::*MemberFuncPtr)(int);

// using: понятно
using MemberFuncPtr = void (MyClass::*)(int);

Вложенные типы и зависимые имена (dependent names)

В шаблонах using избавляет от необходимости писать typename при обращении к вложенным типам. Рассмотрим классический пример с аллокатором из стандартной библиотеки:

// Без using — нужно typename
template<typename T>
struct MyContainer {
    // typename обязателен, потому что T::allocator_type — зависимое имя
    typename T::allocator_type alloc;
};

// С using — typename не нужен
template<typename T>
using Allocator = typename T::allocator_type;

template<typename T>
struct MyContainer {
    Allocator<T> alloc;  // чисто и понятно
};

Когда typedef все еще полезен?

typedef полностью эквивалентен using для простых, нешаблонных случаев. Оба создают синоним типа, и с точки зрения компилятора разницы нет:

typedef int MyInt;
using MyInt = int;  // абсолютно то же самое

typedef std::map<std::string, int> StringIntMap;
using StringIntMap = std::map<std::string, int>;  // то же самое

Единственная причина использовать typedef сегодня — это поддержка старого кода или работа с компиляторами, которые не поддерживают C++11 (что редкость).

Практические рекомендации

• Всегда используйте using для нового кода. Это стандарт де-факто в современном C++ (C++11 и новее).
• using читается интуитивнее: «пусть X будет равен Y».
• using единственный способ объявить шаблонный псевдоним.
• using легче парсить компилятору и человеку (меньше скобок, звездочек и путаницы).
• typedef оставьте для поддержки легаси-кода или если ваш проект застрял на C++03.

Итог

Ключевая разница: using — это современный, более мощный и читаемый способ, который поддерживает шаблонные псевдонимы. typedef — устаревший синтаксис из C, который не стоит использовать в новом коде на C++11 и выше.

std::remove_reference_t<T>  // эквивалентно typename std::remove_reference<T>::type

namespace std {
    template<typename T>
    using remove_reference_t = typename remove_reference<T>::type;
}

template<typename T>
using UniquePtr = std::unique_ptr<T, std::function<void(T*)>>;

// Использование:
UniquePtr<FILE> file(fopen("test.txt", "r"), &fclose);