Attributes

Attributes are small statements we can add to our code to give the compiler, or other developers, guidance. Attributes can be identified by the [[ and ]] that surround them.

There are many attributes we can use, and more are being added regularly. We cover some of the most useful ones in this lesson:

• [[nodiscard]] indicates that we expect a function’s return value to be used. If it is discarded, the compiler will generate a warning
• [[likely]] and [[unlikely]] within conditional logic give the compiler guidance over which code path we expect to be taken, allowing it to optimize around the likely path
• [[deprecated]] gives other developers guidance that we’d prefer they not use a specific function or class, as we intend to remove it soon.

The [[nodiscard]] Attribute

Let's consider the following code:

1int Add(int x, int y) {
2  return x+y;
3}
4
5int main() {
6  Add(1, 2);
7}

This is simple and compiles as expected. However, if someone wrote code like this, they certainly made an error.

This is because the only thing our Add function does is return a value. Yet, when Add is called, that return value is being ignored.

So, the call to Add isn’t doing anything. The developer probably misunderstood how our function works and is about to introduce a bug, or may just be wasting resources.

If we annotate the Add function with a [[nodiscard]] attribute, our program still works as expected, but the compiler now helpfully warns us of the issue:

1[[nodiscard]]
2int Add(int x, int y) {
3  return x+y;
4}
5
6int main() {
7  Add(1, 2);
8}

1warning: Ignoring return value of function declared with 'nodiscard' attribute

The [[likely]] and [[unlikely]] Attributes

When we’re creating conditional logic, sometimes one of our branches is much more likely to be followed. When we know that, we can provide that insight to the compiler, using [[likely]]:

1void StartQuest(Character* Player) {
2  if (Player->IsAlive()) [[likely]] {
3    // ...
4  }
5  // ...
6}

Similarly, we can inform the compiler that a condition is unlikely to be true using the [[unlikely]] attribute:

1void Resurrect(Character* Target) {
2  if (Target->IsAlive()) [[unlikely]] {
3    // ...
4  }
5  // ...
6}

When the compiler knows a path is going to be very commonly used within our function, it can optimize the compilation of that function accordingly.

This gives a performance benefit. Additionally, other developers reading our code can get a sense of the expected context.

For example, reading this example, we know that it is possible that our Resurrect function could be given a Target that is already alive, but it’s not likely.

The [[deprecated]] Attribute

The final attribute we want to cover is [[deprecated]]. It is common for us to want to change or remove a function.

But, that function may be used in hundreds or thousands of other places. This is particularly common when we’re working on a large project with colleagues, or working on a library that is being used in other projects.

Instead of attempting to remove it, it’s common to instead mark it as deprecated. This allows our function to still be used, but anyone using it will get a warning asking them to update their code.

Then, after some time, we can remove the function entirely, with less disruption. We can do this using the [[deprecated]] attribute:

1[[deprecated]]
2void StartQuest(Character* Player) {
3  // ...
4}

Now, code that calls this function will still work, but they will get a compiler warning:

1'StartQuest' is deprecated

Generally, we will want to give more information - for example, what should the consumer use instead? We can update our [[deprecated]] attribute to include a message:

1[[deprecated(
2  "StartQuest(Character*) will be removed"
3  "soon - switch to StartQuest(QuestJournal*)"
4)]]
5void StartQuest(Character* Player) {
6  // ...
7}
8
9void StartQuest(QuestJournal* Journal) {
10  // ...
11}

1warning C4996: 'StartQuest': StartQuest(Character*) will be removed soon - switch to StartQuest(QuestJournal*)

There are many more attributes we can use. Additionally, compilers often introduce their own, non-standard attributes, which we can include in our code if we’re using that compiler.

However, this summary introduced the most common and useful attributes.

Summary

In this lesson, we've explored the concept of attributes. The key things we learned included:

• Learned the use of [[nodiscard]] to prevent discarding important return values and to catch potential errors.
• Understood how [[likely]] and [[unlikely]] attributes guide the compiler for optimization by indicating the expected path in conditional logic.
• Explored the [[deprecated]] attribute to manage the evolution of code by marking functions or entities for future removal.
• Gained insights into the importance of compiler-guided optimization and how attributes contribute to efficient code execution.
• Discussed the concept of function side effects and when it's appropriate to use certain attributes.

Preview of the Next Lesson

In the upcoming lesson, we delve into the world of randomness in C++. This allows us to introduce non-deterministic results in our program, which we demonstrate in the context of a combat system for a role-playing game. The key topics we’ll cover include**:**

• Understanding Random Number Generation: Learn the basics of how random numbers are generated in C++ and their applications.
• Seeding Random Number Generators: Understand how to seed a random number generator, including how to control the seed to allow for repeatable results.
• Different Random Engines in C++: Understand the purpose of random number engines, like std::mt19937.
• Distributions and Their Uses: Explore different types of distributions (like uniform, normal, etc.) and how they shape random data for various use cases.

Next Lesson

Random Number Generation

This lesson covers the basics of using randomness, with practical applications

ContinueView Course