C++ 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 template classes.

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 pair data type is available by including <utility>. It lets us store two objects in a single variable. We specify the types we will be using within the < and > syntax:

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

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

1#include <utility>
2
3std::pair<int, bool> MyPair { 42, true };
4MyPair.first // 42;
5MyPair.second // true;
6

This is all we need to know about std::pair for now, but a full overview is available here:

Storing two values in a single variable using std::pair

An introduction to the std::pair data structure within the C++ standard library.

Why we need type aliases

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

We might have a consumable item in our inventory, alongside an integer quantity. We could store that as a std::pair<const ConsumableItem&, int>:

1#include <utility>
2
3class ConsumableItem {
4public:
5  void Consume() const {}
6};
7
8void ConsumeInventoryItem(
9  std::pair<const ConsumableItem&, int> Item
10) {
11  if (Item.second > 0) {
12	  Item.first.Consume();
13	  Item.second--;
14  }
15}
16
17int main() {
18  ConsumableItem HealthPotion;
19  int Quantity { 100 };
20
21  std::pair<const ConsumableItem&, int> Item {
22	  HealthPotion, Quantity
23  };
24
25  ConsumeInventoryItem(Item);
26}
27

In the above code, we’re using the following type:

1std::pair<const ConsumableItem&, int>
2

This has three problems:

• Having to type so many characters to specify a type is annoying
• Having it repeatedly show up in our code is making our functions hard to follow. 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.
• The type has no semantic meaning, so it’s not clear what it even represents. Anyone reading our code will immediately know or can infer what types like int or Monster represent, but it takes some digging and assumptions to work out that std::pair<const ConsumableItem&, int> is supposed to be an inventory slot.

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 InventorySlot =
2  std::pair<const ConsumableItem&, int>;
3

This has at least two benefits

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

Using Type Aliases

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

1#include <utility>
2
3class ConsumableItem {
4public:
5  void Consume() const {
6  }
7};
8
9using InventorySlot =
10  std::pair<const ConsumableItem&, int>;
11
12void ConsumeInventoryItem(InventorySlot Item) {
13  if (Item.second > 0) {
14	  Item.first.Consume();
15	  Item.second--;
16  }
17}
18
19int main() {
20  ConsumableItem HealthPotion;
21  int Quantity { 100 };
22
23  InventorySlot Item { HealthPotion, Quantity };
24
25  ConsumeInventoryItem(Item);
26}
27

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:

1ConsumableItem HealthPotion;
2InventorySlot Potions { HealthPotion, 100 };
3Potions.second++;
4
5// Pointer to an inventory slot
6InventorySlot* Pointer { &Potions };
7Pointer->second++;
8
9// A constant inventory slot
10const InventorySlot ConstantSlot { Potions };
11ConstantSlot.second++;  // not allowed
12

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 InventorySlot = std::pair<Item*, int>;
2
3int main() {
4  InventorySlot Slot { &CheeseWheel, 100 }
5}
6

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 only be available within that block, including any nested child blocks.

In the following example, line 7 will now throw an error, as the alias is only available within the block created as part of MyFunction

1void MyFunction() {
2  using InventorySlot = std::pair<Item, int>;
3  InventorySlot Slot { BreadRoll, 50 }
4}
5
6int main() {
7  InventorySlot Slot { CheeseWheel, 100 }
8}
9

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 function.

This returns the type of the expression, which we can use anywhere in our code where a type would be expected.

Here are some examples:

1#include <utility>
2
3int main(){
4  std::pair<int, int> SomePair;
5
6  decltype(SomePair) AnotherPair;
7
8  using PairType = decltype(SomePair);
9  PairType AThirdPair;
10}
11

typedef

C++ also offers another way to accomplish type aliasing - typedef.

The concept is very similar, although with typedef, the type comes first, followed by the alias:

1typedef std::pair<const Item&, int> InventorySlot;
2

The support of typedef is mostly for historic reasons, but it still crops up a lot in existing code so it's worth knowing about.

New code should use the using approach, as described previously.