Type Aliases

At this point, we may have noticed our types are getting more and more verbose. This trend is going to continue, particularly once we start using templates later in this chapter.

We’ll cover template classes in more detail later in this chapter. For now, let's introduce a basic example of one from the standard library - the std::pair.

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.

Using std::pair

Master the use of std::pair with this comprehensive guide, encompassing everything from simple pair manipulation to template-based applications

Why do we need 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 being 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.

Creating an alias with using

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 the code that uses it is easier to 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.

Alias Scope

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.

Scope

Learn more about how and when we can access variables, by understanding the importance of the scope in which they exist.

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

Project Wide Aliases

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

Preprocessor Definitions

Explore the essential concepts of C++ preprocessing, from understanding directives to implementing macros

std::conditional

Within <type_traits>, the std::conditional helper lets us choose between one of two types at compile time. This gives is 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

decltype

Occasionally, it will be easier (or necessary) to ask the compiler to figure out what type an expression returns. We can do this using the decltype specifier.

In the following examples, we use decltype simply to set up type aliases, but its applications are much wider ranging as we’ll see through the rest of this chapter.

Below, 42 is an int, so decltype(42) will return int:

1int main() {
2  // SomeType will be an alias for int
3  using SomeType = decltype(42);
4
5  SomeType SomeValue;
6}

The expression we use with decltype does not need to be a simple literal - below, we use it to determine what is returned by a function:

1int SomeFunction() { return 42; }
2
3int main() {
4  // SomeType will be an alias for int
5  using SomeType = decltype(SomeFunction());
6
7  // This will be an int
8  SomeType SomeValue;
9}

We don’t need to use it with a type alias - we can use it almost anywhere a type is expected:

1int SomeFunction() { return 42; }
2
3int main() {
4  // This will be an int
5  decltype(SomeFunction()) SomeValue;
6}

std::declval

In some scenarios, the expression we need to write to determine a type can be quite complex. For example, we might want to get the type returned by some member function: We could construct the object

1struct MyType {
2  int Get(){};
3};
4
5int main() {
6  // Will be int
7  using SomeType = decltype(MyType{}.Get());
8}

But things can get more awkward if the constructor requires arguments:

1struct MyType {
2  MyType(int, float, bool) {}
3  int Get(){};
4};
5
6int main() {
7  // Will be int
8  using SomeType = decltype(
9    MyType{42, 9.8, true}.Get()
10  );
11}

Worse, in more complex scenarios involving templates that we’ll cover later, we won’t even know what type we’re constructing, or what arguments its constructor requires.

To help with this, std::declval within <utility> allows us to create a hypothetical object of a specific type. We can use it like this:

1#include <utility>
2
3struct SomeType {};
4
5int main() {
6  // A hypthetical int
7  std::declval<int>();
8
9  // A hypthetical float
10  std::declval<float>();
11
12  // A hypthetical SomeType
13  std::declval<SomeType>();
14}

This hypothetical object is only useful to assess the characteristics of its type at compile time, such as the return types of its methods.

But, its key advantage is that it doesn’t need to actually construct an object, so we don’t need to provide constructor arguments. We can solve our original problem like this:

1#include <utility>
2
3struct MyType {
4  MyType(int, float, bool) {}
5  int Get(){};
6};
7
8int main() {
9  // Will be int
10  using SomeType = decltype(
11    std::declval<MyType>().Get()
12  );
13}

typedef

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.

Summary

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.
• The decltype specifier is useful for deducing the type of an expression.
• Although typedef is supported for backward compatibility with C and legacy C++ code, using is generally preferred for its readability and compatibility with modern C++ features.

Next Lesson

Class Templates

Learn how templates can be used to create multiple classes from a single blueprint

ContinueView Course