Type Aliases

The std::pair data type is available by including <utility>. It lets us store two objects in a single container. We specify the two types we will be storing within the < and > syntax: For example, to create a std::pair that stores an int and a float, we would use this syntax:

1#include <utility>
2
3std::pair<int, float> MyPair;

We can access each value through the first and second members, respectively:

1#include <utility>
2#include <iostream>
3
4int main() {
5  std::pair<int, float> MyPair{42, 9.8f};
6
7  std::cout << "First " << MyPair.first
8    << "\nSecond " << MyPair.second;
9}

1First: 42
2Second: 9.8

We cover std::pair in full detail later in the course, but for this lesson, we'll just use it as the basis for creating type aliases.

Let's see a more complicated example of a std::pair type, which will show why type aliases can be useful.

We might want to store a Player object, alongside a Guild object that the player is part of. We could store that as the following type:

1std::pair<const Player&, const Guild&>

Below, we show this type in action:

1#include <utility>
2#include <iostream>
3
4struct Player {
5  std::string Name;
6};
7
8struct Guild {
9  std::string Name;
10};
11
12void LogDetails(std::pair<
13  const Player&, const Guild&>& Member) {
14  std::cout << "Player: " << Member.first.Name
15            << ", Guild: " << Member.second.Name;
16}
17
18int main() {
19  Player Anna{"Anna"};
20  Guild Fellowship{"The Fellowship"};
21
22  std::pair<const Player&, const Guild&> Member{
23	  Anna, Fellowship
24  };
25
26  LogDetails(Member);
27}

1Player: Anna, Guild: The Fellowship

Using a type as complex as this can make our code difficult to follow and understand.

It's quite difficult to quickly figure out what our code is doing when so much of the signal is drowned out by the noise of such a complex and verbose type.

Additionally, the type doesn't have as much semantic meaning as it could. If a type is supposed to represent a member of a guild, we'd prefer the type to have a name like GuildMember. Fortunately, we have a way to give our types more friendly names.

We can create an alias for a type using a using statement, as shown below:

1using GuildMember =
2  std::pair<const Player&, const Guild&>;

This has at least two benefits

• Our type is less cumbersome, meaning code that uses it is easier to write and follow
• The alias describes what the type is supposed to represent

We can use the type alias in place of the type, in any location where a type would be expected. Compared to the previous example, the following program has simplified our function signature and our variable creation:

1#include <utility>
2#include <iostream>
3
4struct Player {
5  std::string Name;
6};
7
8struct Guild {
9  std::string Name;
10};
11
12using GuildMember =
13  std::pair<const Player&, const Guild&>;
14
15void LogDetails(GuildMember& Member) {
16  std::cout << "Player: " << Member.first.Name
17            << ", Guild: " << Member.second.Name;
18}
19
20int main() {
21  Player Anna{"Anna"};
22  Guild Fellowship{"The Fellowship"};
23
24  GuildMember Member{Anna, Fellowship};
25
26  LogDetails(Member);
27}

1Player: Anna, Guild: The Fellowship

Through the alias, we can freely add qualifiers to the underlying type. This can include things like * or & to make it a pointer or a reference type, and const to make it a constant:

1using Integer = int;
2
3int main() {
4  // Value
5  Integer Value;
6
7  // Reference
8  Integer& Ref{Value};
9
10  // Const Reference
11  const Integer& ConstRef{Value};
12
13  // Pointer
14  Integer* Ptr;
15
16  // Const pointer to const
17  const Integer* const CPtr{&Value};
18}

The alias also does not prevent us from using the original type name. In the previous example, we aliased int to Integer, but we could still use int where preferred, such as in the main function's return type.

Aliases are scoped in the same way as any of our other declarations.

This means aliases can have global scope, by being defined outside of any block:

1using Integer = int;
2
3int main() {
4  Integer SomeValue;
5}

Alternatively, aliases can be defined within a block, such as one created by a function, namespace (including an anonymous namespace) or an if statement.

When this is done, the alias will follow normal scoping rules. Typically, this means it will only be available within that block, including any nested child blocks.

In the following example, we will get a compilation error, as the Integer alias is only available within the scope of MyFunction

1void SomeFunction() {
2  using Integer = int;
3  // ...
4}
5
6int main() {
7  Integer SomeValue; 
8}

1error: 'Integer': undeclared identifier

Another common use case for type aliases is to specify types that we believe may need to change across our whole project. One way to implement this is to define all our aliases in a header file that gets included in every other file in our project.

In this example, we want our project to use the int32_t type for integers, which use 32 bits (4 bytes) of memory:

1// types.h
2#pragma once
3#include <cstdint>
4
5using Integer = int32_t;

1#include <iostream>
2#include "types.h"
3
4int main() {
5  // Will be int32_t
6  Integer SomeInt;
7
8  std::cout << "Integer size: "
9    << sizeof(Integer) << " bytes";
10}

1Integer size: 4 bytes

The benefit of this approach is that if we want to change a type across our entire project, we now only need to change the alias, which is defined in a single place. This also allows us to change the type at compile time, with help from preprocessor definitions:

1//types.h
2#pragma once
3#include <cstdint>
4
5#ifdef USE_64_BIT_INTS
6  using Integer = int64_t;
7#else
8  using Integer = int32_t;
9#endif

Within <type_traits>, the std::conditional helper lets us choose between one of two types at compile time. This gives us a way to implement the behaviour of the previous example using C++ rather than the preprocessor.

std::conditional accepts three template parameters:

1. A boolean value that is known at compile time
2. A type to use if the boolean is true
3. A type to use if the boolean is false

The resulting type is available from the type static member:

1#include <cstdint>
2#include <type_traits>
3#include <iostream>
4
5constexpr bool Use64BitInts{true};
6
7using Integer = std::conditional<
8  Use64BitInts, int64_t, int32_t
9>::type;
10
11int main() {
12  std::cout << "Integer size: "
13    << sizeof(Integer) << " bytes";
14}

1Integer size: 8 bytes

Rather than accessing ::type, we can alternatively use std::conditional_t, which returns the resolved type directly:

1#include <cstdint>
2#include <type_traits>
3#include <iostream>
4
5constexpr bool Use64BitInts{true};
6
7using Integer = std::conditional_t<
8  Use64BitInts, int64_t, int32_t>;
9
10int main() {
11  std::cout << "Integer size: "
12    << sizeof(Integer) << " bytes";
13}

1Integer size: 8 bytes

The C language implemented type aliases using the typedef keyword, and this is still supported in C++. Instead of:

1using Integer = int;

We could write:

1typedef int Integer;

The support of typedef is mostly for historical reasons, but it still crops up a lot in existing code. In general, we should prefer the using approach. Most people find using more readable, and it is also compatible with templates, which we'll cover later in this chapter.

In this lesson, we explored type aliases, learning how to simplify and give semantic meaning to complex types, The key takeaways include:

• Type aliases help simplify verbose or complex type declarations, making code easier to understand and maintain.
• The using keyword allows for the creation of type aliases.
• Type aliases can be scoped globally or locally, following normal C++ scoping rules to control visibility.
• Project-wide type aliases enable consistent type usage across a project and can be easily changed from a single location.
• The type an alias uses can be conditionally set at compile time, using the preprocessor or std::conditional.