The using Keyword

When dealing with excessively verbose code, C++ provides a few options for us to reduce the noise. Typically, these options have the using syntax. We’ll explore the four main uses for it in this lesson:

• Reducing the amount of code we need to write when working with namespaces
• Reducing the amount of code we need to write when working with enums
• Changing the types our program uses based on a preprocessor definition
• Giving complex types shorter or more meaningful names

using namespace Statements

Starting from the very first lesson, we've had a line of code in our files that we've left unexplained thus far:

1using namespace std;

Predictably, this line is related to namespaces.

The effect of this using declaration was an instruction that asks the compiler: "if an identifier we use is not found, try searching for it in the std namespace".

This using statement has been necessary every time we used cout and string. This is because the standard library functionality, including these identifiers, is in the std namespace:

1#include <iostream>
2
3int main() {
4  std::string MyString{"Hello"};
5  std::cout << MyString;
6}

By adding a using namespace std declaration, we have the option of removing the std:: prefix:

1#include <iostream>
2using namespace std;
3
4int main() {
5  string MyString{"Hello"};
6  cout << MyString;
7}

We can use using namespace declarations with any namespace - not just std:

1namespace Maths {
2  float Pi { 3.14f };
3}
4
5using namespace Maths;
6using namespace std;
7
8int main() {
9  // equivalent to std::cout << Maths::Pi
10  cout << Pi;
11}

1namespace Utilities {
2  void Square() {};
3};
4
5// ?
6
7Square();

Restrict using Declarations to Specific Identifiers

Rather than having a using statement that covers the entire std namespace, we can also restrict it just to specific identifiers.

For example, to use it with just std::cout and std::string, we could write this:

1#include <iostream>
2
3using std::cout, std::string;
4
5int main() {
6  string MyString{"Hello World"};
7  cout << MyString;
8}

1Hello World

Should I use using namespace Statements?

Probably not. Namespaces exist to help us organize code - a using namespace declaration effectively subverts that organization.

Remember too how #include directives work - if we have a using namespace declaration that is scoped to an entire file, that would also affect any file that includes it.

This can cause things to get out of hand quite quickly so, if using namespace declarations are going to be adopted, be particularly cautious when using them on files that are likely to be included in other files.

The Unreal coding standard asks for using declarations to never be used in the global scope. We talk about non-global using statements later in this lesson:

And the Google C++ standard asks that using declarations never be used, anywhere:

If we want to use using statements, there are two ways we can get the benefits whilst reducing many of the drawbacks.

• Restrict them to the specific identifiers we need - eg using std::string.
• Reduce the scope of the using statement, which we cover in the next lesson

Scoped using Declarations

All of the using declarations we cover in this lesson follow the normal block scoping rules of other statements. A using declaration outside of any block has a "global" scope and will apply to the entire file.

This can be problematic, especially if that file is then added to further files, via the #include directive.

As an alternative to global using declarations, we can place them inside blocks - usually function bodies or other namespaces. This will limit their effect to just the scope of that block.

1#include <iostream>
2
3void Hello() {
4  // This using statement's effects are
5  // limited to just this function block
6  using namespace std;
7  cout << "Hello ";
8}
9
10void World() {
11  // Error - there are no using
12  // statements in effect in this scope
13  cout << "World";  
14}
15
16int main() {
17  Hello();
18  World();
19}

1error C2065: 'cout': undeclared identifier

using enum Statements (C++20)

In some files, we may want to use the same enum repeatedly, and the constant qualification of MyEnumName:: would make our code excessively verbose.

We can solve this problem in the same we we tacked the equivalent issue with namespaces - by adding a using statement - specifically a using enum statement:

This can take our code from something like this:

1enum class Faction { Human, Elf, Undead };
2
3Faction MyFaction { Faction::Human };

To this:

1enum class Faction { Human, Elf, Undead };
2
3using enum Faction;
4
5Faction MyFaction { Human };

Note, using enum is a relatively recent addition to the language, included as part of the C++20 spec. In projects that use older compilers, it will not be available.

1enum class Hostility { Friendly, Neutral, Hostile };
2
3// ?
4
5class Character {
6  Hostility Hostility { Friendly };
7};

Type aliases with using

The final scenario where we want to demonstrate a using statement is for type aliasing.

This allows us to create a pseudonym for a type we want to use in our code:

1using integer = int;
2
3int main() {
4  integer MyNumber{42};
5}

There are two main uses for this.

1. Switching Types at Compile Time

The first use case is to change what types we use based on a preprocessor definition.

For example, perhaps we want the specific type of integer we’re using to be different between platforms.

Rather than scattering that logic throughout our code, we could keep it in one place.

Below, we’re using int64_t and int32_t, which work like the int type we’ve been using so far. The only difference is that int64_t and int32_t are fixed-width integers.

That is, they specify exactly how many bits they use, rather than letting the platform decide:

1#pragma once
2#include <cstdint>
3
4#ifdef PLATFORM_64BIT
5  using integer = std::int64_t;
6#else
7  using integer = std::int32_t;
8#endif

We then #include this file in all our other files, and use our new integer alias like any other type:

1#include "types.h"
2
3int main() {
4  integer MyNumber{42};
5}

2. Aliasing Complex Types

The second use case for type aliases with the using statement is to give complex types shorter, or more meaningful names.

This is of limited use for now when we’re dealing with simple types like int and string but, in C++, types can get fairly complex.

In the future, we’ll see types like the one used by this Inventory variable:

1std::unordered_map<
2  Enums::ItemType, std::vector<Item&>
3> Inventory;

Scattering a type like this through our function prototypes in a class declaration, for example, would get very messy. So, we can use a using statement to create a simpler alias:

1using Items = std::unordered_map<
2  Enums::ItemType, std::vector<Item&>>;
3
4class Character {
5public:
6  void SetInventory(Items Inventory) {
7    mInventory = Inventory;
8  }
9  Items GetInventory() { return mInventory; }
10private:
11  Items mInventory;
12};

1typedef int integer;
2
3int main() {
4  integer MyNumber;
5}

Summary

This lesson delves into the use of using directives, exploring their applications in reducing verbosity, managing namespaces, and simplifying code through type aliasing

Key Learnings:

• The using namespace statement allows for shorter code by omitting the namespace prefix, particularly with the standard (std) namespace.
• Scoped using declarations can be confined to specific blocks like function bodies, reducing their global impact.
• The using enum statement simplifies enum usage by eliminating the need for enum class qualification.
• Type aliasing with using enables switching types at compile time and giving complex types more meaningful names.
• Caution around the using namespace statement is recommended, particularly in the global scope.

Preview of the Next Chapter

In our upcoming chapter, we'll explore the principles of creating robust, maintainable code. We'll delve into topics like:

• Simplifying variable declarations and improving code readability with automatic type inference.
• Understanding and implementing const-correctness.
• Utilizing automatic code formatting tools to maintain consistent coding styles.
• Leveraging static analysis for identifying potential errors and code smells.
• Employing attributes for hints to the compiler and colleagues.
• Formatting comments using Javadoc, enabling additional functionality in IDEs and other tools.

Next Lesson

Automatic Type Deduction using auto

This lesson covers how we can ask the compiler to infer what types we are using through the auto keyword

ContinueView Course