Modern C++11 - Day 4: using Alias

After learning using alias, you should understand:

1. Why C++11 introduced `using` alias.
2. How it improves readability compared to long type names.
3. The difference between `using` and `typedef`.
4. Common mistakes when creating aliases.
5. How aliases help in real-world C++ code.

In C++, type names can become long and hard to read, especially with STL containers.

Example:

std::unordered_map<std::string, std::vector<double>>

A using alias gives a readable name to a type:

using PriceHistory = std::unordered_map<std::string, std::vector<double>>;

Main idea:

Give a complex type a clear, meaningful name.

This makes code shorter, easier to read, and easier to maintain.

Basic alias:

using NewName = ExistingType;

Examples:

using Price = double;
using Quantity = int;
using Symbol = std::string;

Alias for STL containers:

using PriceHistory = std::unordered_map<std::string, std::vector<double>>;

Alias for function pointers:

using Handler = void(*)(int);

Alias template:

template <typename T>
using Vec = std::vector<T>;

Old style:

typedef long long ll;

Modern C++ style:

using ll = long long;

For simple types, both work.

But using is usually clearer, especially for complex types and templates.

Alias templates are much cleaner with using:

template <typename T>
using Vec = std::vector<T>;

5.1. Hiding important domain meaning

using Price = double;
using Quantity = double;

Both are double, so the compiler cannot prevent mixing them.

Aliases improve readability, but they do not create new strong types.

5.2. Overusing aliases

Too many aliases can make code harder to understand.

Use aliases only when they make the code clearer.

5.3. Confusing alias with a new type

using Price = double;

This does not create a new independent type.

It is just another name for double.

Use using when:

1. A type name is too long.
2. The alias improves domain readability.
3. You want to simplify STL container types.
4. You want cleaner function pointer declarations.
5. You want alias templates.

Avoid it when:

1. The original type is already simple.
2. The alias hides too much information.
3. Too many aliases make the code harder to navigate.

Trading code often has domain concepts such as:

Price
Quantity
Symbol
OrderId
Timestamp
OrderBook

Aliases can make code more readable:

using Price = double;
using Quantity = int;
using Symbol = std::string;

However, remember:

A type alias is not a new strong type.
It only gives another name to an existing type.

For stronger type safety, you need wrapper structs or strong typedef patterns.

You should remember:

using NewName = ExistingType;

You should be able to answer:

1. Why is `using` useful?
2. How is it different from `typedef`?
3. Does `using Price = double` create a new type?
4. When can aliases make code harder to read?
5. Why are alias templates useful?

using alias is a small but practical C++11 feature.

The key idea:

Use `using` to give long or domain-specific types clearer names.
Do not overuse it, and remember that an alias is not a new type.

:::