13.15 — Alias templates

In this lesson, you'll learn about alias templates - a powerful feature that allows you to create shortcuts and more readable names for complex template types, making your code cleaner and more maintainable.

The problem with complex template names

As you work with templates, especially with multiple parameters or nested templates, type names can become quite complex:

#include <iostream>
#include <vector>
#include <map>
#include <string>

int main()
{
    // These type names are getting unwieldy
    std::vector<std::pair<std::string, int>> studentGrades;
    std::map<std::string, std::vector<double>> subjectScores;
    std::vector<std::map<std::string, std::pair<int, double>>> complexData;
    
    // Imagine having to type these throughout your code!
    studentGrades.push_back({"Alice", 95});
    studentGrades.push_back({"Bob", 87});
    
    subjectScores["Math"] = {95.5, 87.2, 92.0};
    subjectScores["Science"] = {88.0, 91.5, 89.7};
    
    std::cout << "Student grades: " << studentGrades.size() << std::endl;
    std::cout << "Subject scores: " << subjectScores.size() << std::endl;
    
    return 0;
}

Output:

Student grades: 2
Subject scores: 2

These type names are hard to read, difficult to type, and prone to errors.

Introduction to alias templates

Alias templates allow you to create shorter, more descriptive names for complex template types:

#include <iostream>
#include <vector>
#include <map>
#include <string>

// Alias templates for cleaner type names
template<typename T>
using Vector = std::vector<T>;

template<typename Key, typename Value>
using Map = std::map<Key, Value>;

// More specific aliases
using StudentGrade = std::pair<std::string, int>;
using StudentGrades = Vector<StudentGrade>;
using SubjectScores = Map<std::string, Vector<double>>;

int main()
{
    // Much cleaner and more readable!
    StudentGrades studentGrades;
    SubjectScores subjectScores;
    
    studentGrades.push_back({"Alice", 95});
    studentGrades.push_back({"Bob", 87});
    
    subjectScores["Math"] = {95.5, 87.2, 92.0};
    subjectScores["Science"] = {88.0, 91.5, 89.7};
    
    std::cout << "Student grades: " << studentGrades.size() << std::endl;
    std::cout << "Subject scores: " << subjectScores.size() << std::endl;
    
    return 0;
}

Output:

Student grades: 2
Subject scores: 2

The code is now much more readable and maintainable!

Alias template syntax

The basic syntax for alias templates is:

template<template_parameters>
using alias_name = existing_type;

Here are various examples:

#include <iostream>
#include <vector>
#include <memory>
#include <functional>

// Simple alias for a template
template<typename T>
using Ptr = std::unique_ptr<T>;

// Alias with multiple parameters
template<typename T, typename Allocator>
using MyVector = std::vector<T, Allocator>;

// Alias that fixes some template parameters
template<typename T>
using IntMap = std::map<int, T>;

// Alias for function types
template<typename T>
using Predicate = std::function<bool(const T&)>;

template<typename T>
using Transform = std::function<T(const T&)>;

int main()
{
    // Using the aliases
    Ptr<int> intPtr = std::make_unique<int>(42);
    IntMap<std::string> idToName;
    
    idToName[1001] = "Alice";
    idToName[1002] = "Bob";
    
    // Function-type aliases
    Predicate<int> isEven = [](const int& n) { return n % 2 == 0; };
    Transform<int> square = [](const int& n) { return n * n; };
    
    std::cout << "Value: " << *intPtr << std::endl;
    std::cout << "Name for ID 1001: " << idToName[1001] << std::endl;
    std::cout << "Is 4 even? " << (isEven(4) ? "Yes" : "No") << std::endl;
    std::cout << "Square of 5: " << square(5) << std::endl;
    
    return 0;
}

Output:

Value: 42
Name for ID 1001: Alice
Is 4 even? Yes
Square of 5: 25

Partial template specialization with aliases

Alias templates can partially specialize complex types:

#include <iostream>
#include <vector>
#include <deque>
#include <list>

// Generic container alias
template<typename T, template<typename> class Container>
using GenericContainer = Container<T>;

// Specific container aliases
template<typename T>
using DynamicArray = std::vector<T>;

template<typename T>
using Queue = std::deque<T>;

template<typename T>
using LinkedList = std::list<T>;

// Alias that adds default allocator
template<typename T>
using SafeVector = std::vector<T, std::allocator<T>>;

void printSizes()
{
    DynamicArray<int> numbers{1, 2, 3, 4, 5};
    Queue<std::string> messages{"hello", "world"};
    LinkedList<double> values{1.1, 2.2, 3.3};
    
    std::cout << "Numbers: " << numbers.size() << " elements" << std::endl;
    std::cout << "Messages: " << messages.size() << " elements" << std::endl;
    std::cout << "Values: " << values.size() << " elements" << std::endl;
}

int main()
{
    printSizes();
    return 0;
}

Output:

Numbers: 5 elements
Messages: 2 elements
Values: 3 elements

Practical example: Database record templates

Here's a real-world example showing how alias templates can make database-related code more readable:

#include <iostream>
#include <vector>
#include <map>
#include <string>
#include <optional>

// Basic database types
using ID = int;
using Timestamp = std::string;  // Simplified for example

// Generic record templates
template<typename T>
using Record = std::map<std::string, T>;

template<typename T>
using RecordSet = std::vector<Record<T>>;

template<typename T>
using OptionalRecord = std::optional<Record<T>>;

// Specific record types
using UserRecord = Record<std::string>;
using ProductRecord = Record<std::string>;
using OrderRecord = Record<std::string>;

// Collections
using Users = RecordSet<std::string>;
using Products = RecordSet<std::string>;
using Orders = RecordSet<std::string>;

// Database result types
template<typename T>
using QueryResult = std::optional<RecordSet<T>>;

class SimpleDatabase
{
private:
    Users users;
    Products products;
    
public:
    void addUser(ID id, const std::string& name, const std::string& email)
    {
        UserRecord user;
        user["id"] = std::to_string(id);
        user["name"] = name;
        user["email"] = email;
        users.push_back(user);
    }
    
    void addProduct(ID id, const std::string& name, const std::string& price)
    {
        ProductRecord product;
        product["id"] = std::to_string(id);
        product["name"] = name;
        product["price"] = price;
        products.push_back(product);
    }
    
    QueryResult<std::string> findUsersByName(const std::string& name)
    {
        Users results;
        for (const auto& user : users)
        {
            if (user.at("name").find(name) != std::string::npos)
            {
                results.push_back(user);
            }
        }
        return results.empty() ? std::nullopt : std::make_optional(results);
    }
    
    void printUsers() const
    {
        std::cout << "=== Users ===" << std::endl;
        for (const auto& user : users)
        {
            std::cout << "ID: " << user.at("id") 
                      << ", Name: " << user.at("name")
                      << ", Email: " << user.at("email") << std::endl;
        }
    }
};

int main()
{
    SimpleDatabase db;
    
    db.addUser(1, "Alice Johnson", "alice@email.com");
    db.addUser(2, "Bob Smith", "bob@email.com");
    db.addUser(3, "Alice Brown", "alice.brown@email.com");
    
    db.addProduct(101, "Laptop", "999.99");
    db.addProduct(102, "Mouse", "29.99");
    
    db.printUsers();
    
    auto aliceUsers = db.findUsersByName("Alice");
    if (aliceUsers)
    {
        std::cout << "\nFound " << aliceUsers->size() << " users named Alice:" << std::endl;
        for (const auto& user : *aliceUsers)
        {
            std::cout << "- " << user.at("name") << " (" << user.at("email") << ")" << std::endl;
        }
    }
    
    return 0;
}

Output:

=== Users ===
ID: 1, Name: Alice Johnson, Email: alice@email.com
ID: 2, Name: Bob Smith, Email: bob@email.com
ID: 3, Name: Alice Brown, Email: alice.brown@email.com

Found 2 users named Alice:
- Alice Johnson (alice@email.com)
- Alice Brown (alice.brown@email.com)

Alias templates vs typedef

Alias templates are more powerful than traditional typedef because they can be templated:

#include <iostream>
#include <vector>
#include <map>

// typedef - only works for specific types
typedef std::vector<int> IntVector;
typedef std::map<std::string, int> StringIntMap;

// Alias template - works with any type
template<typename T>
using Vector = std::vector<T>;

template<typename Key, typename Value>
using Map = std::map<Key, Value>;

int main()
{
    // typedef usage - limited to specific types
    IntVector intVec{1, 2, 3};
    StringIntMap stringIntMap{{"Alice", 25}, {"Bob", 30}};
    
    // Alias template usage - works with any types
    Vector<double> doubleVec{1.1, 2.2, 3.3};
    Vector<std::string> stringVec{"hello", "world"};
    Map<int, std::string> intStringMap{{1, "one"}, {2, "two"}};
    
    std::cout << "IntVector size: " << intVec.size() << std::endl;
    std::cout << "DoubleVector size: " << doubleVec.size() << std::endl;
    std::cout << "StringVector size: " << stringVec.size() << std::endl;
    
    return 0;
}

Output:

IntVector size: 3
DoubleVector size: 3
StringVector size: 2

Advanced alias template patterns

1. Conditional aliases

#include <iostream>
#include <vector>
#include <array>
#include <type_traits>

template<typename T, bool IsDynamic>
using Container = std::conditional_t<IsDynamic, std::vector<T>, std::array<T, 10>>;

int main()
{
    Container<int, true> dynamicContainer;   // std::vector<int>
    Container<int, false> staticContainer;   // std::array<int, 10>
    
    dynamicContainer.push_back(42);
    staticContainer[0] = 42;
    
    std::cout << "Dynamic container size: " << dynamicContainer.size() << std::endl;
    std::cout << "Static container size: " << staticContainer.size() << std::endl;
    
    return 0;
}

Output:

Dynamic container size: 1
Static container size: 10

2. Member type aliases

#include <iostream>
#include <vector>

template<typename Container>
using ValueType = typename Container::value_type;

template<typename Container>
using Iterator = typename Container::iterator;

template<typename Container>
using SizeType = typename Container::size_type;

template<typename Container>
void printContainerInfo(const Container& c)
{
    std::cout << "Container size: " << c.size() << std::endl;
    std::cout << "Value type size: " << sizeof(ValueType<Container>) << " bytes" << std::endl;
    std::cout << "Size type size: " << sizeof(SizeType<Container>) << " bytes" << std::endl;
}

int main()
{
    std::vector<double> vec{1.1, 2.2, 3.3};
    printContainerInfo(vec);
    
    return 0;
}

Output:

Container size: 3
Value type size: 8 bytes
Size type size: 8 bytes

Best practices for alias templates

1. Use meaningful names

// Good: descriptive names
template<typename T>
using UniquePtr = std::unique_ptr<T>;

template<typename T>
using SharedPtr = std::shared_ptr<T>;

// Less clear: abbreviated names
template<typename T>
using UP = std::unique_ptr<T>;  // What does UP mean?

2. Group related aliases

// Database-related aliases
namespace db 
{
    using ID = int;
    using Timestamp = std::chrono::system_clock::time_point;
    
    template<typename T>
    using Record = std::map<std::string, T>;
    
    template<typename T>
    using RecordSet = std::vector<Record<T>>;
}

// Graphics-related aliases
namespace gfx
{
    using Color = std::array<float, 4>;
    using Point2D = std::pair<float, float>;
    using Point3D = std::array<float, 3>;
}

3. Use aliases to hide complexity

#include <functional>

// Hide complex function signature
template<typename T>
using Validator = std::function<bool(const T&)>;

template<typename T>
using Transformer = std::function<T(const T&)>;

// Much cleaner than writing std::function<bool(const T&)> everywhere
template<typename T>
class DataProcessor
{
    Validator<T> validator;
    Transformer<T> transformer;
    
public:
    DataProcessor(Validator<T> v, Transformer<T> t) : validator(v), transformer(t) {}
    
    T process(const T& data)
    {
        if (validator(data))
        {
            return transformer(data);
        }
        return data;
    }
};

Common use cases

1. Simplifying standard library types

template<typename T>
using Ptr = std::unique_ptr<T>;

template<typename T>
using Ref = std::shared_ptr<T>;

template<typename T>
using Weak = std::weak_ptr<T>;

2. Creating domain-specific type vocabularies

// Game development
using PlayerID = int;
using Score = int;
using Position = std::pair<float, float>;

template<typename T>
using GameObjectPtr = std::shared_ptr<T>;

3. Platform-specific type abstractions

#ifdef PLATFORM_64BIT
    using Handle = std::uint64_t;
#else
    using Handle = std::uint32_t;
#endif

template<typename T>
using PlatformVector = std::vector<T>;  // Could be different on different platforms

Key concepts to remember

1. Alias templates create shortcuts for complex template type names.

2. Alias templates are more powerful than typedef because they can be parameterized.

3. Use meaningful names that clearly indicate the purpose of the alias.

4. Alias templates improve code readability and maintainability.

5. Group related aliases in namespaces or logical sections.

6. Alias templates don't create new types - they're just alternative names for existing types.

Summary

Alias templates are a powerful feature that significantly improves code readability and maintainability by providing clean, descriptive names for complex template types. They're especially valuable when working with nested templates, standard library containers, and domain-specific type vocabularies. By using alias templates effectively, you can make your code more expressive and easier to understand, while reducing the likelihood of typing errors in complex template instantiations. They're an essential tool for creating clean, professional C++ code that's easy to read and maintain.

Quiz

1. What are alias templates and how do they differ from typedef?
2. How do you create an alias template with multiple template parameters?
3. What are the benefits of using alias templates in complex codebases?
4. How can alias templates improve code readability and maintainability?
5. When should you consider using alias templates instead of the original type names?

Practice exercises

Try these exercises with alias templates:

1. Create a set of alias templates for common standard library containers (std::vector, std::map, std::set) and use them in a simple program.
2. Design alias templates for a specific domain (e.g., graphics programming, database operations) and create a small program that uses them.
3. Create alias templates that partially specialize complex standard library types (e.g., std::function, std::shared_ptr) and demonstrate their usage.
4. Refactor an existing program with complex template types to use alias templates, comparing the readability before and after.