Static Casting

We've previously seen how our data types can be converted to other types automatically. For example, we can use an int in a location where a float is expected, and our int is just automatically converted to the equivalent float:

1float MyNumber { 4 };

These are called implicit conversions, because we don't need to write any additional code to make them happen.

We also have the option, and sometimes the need, to perform explicit conversions. This involves writing some additional code, making it clear that we're performing a conversion, and what we're converting our expression to. Explicit conversions are referred to as type casting, or just casting.

C++ offers many different styles of casting. The two most common forms we need are static casting which is done at build time, and dynamic casting which is done at run time. We'll look at dynamic casting later in the course.

Because static casting lets us convert our data at build time, this means it has two useful properties:

• There is a minimal performance impact, and often no performance impact at all
• The compiler can check if the cast is possible and throw an error if not, preventing us from introducing bugs

To convert the integer 5 to a float, we can do this:

1static_cast<float>(5)

To convert the double 5.0 to an int, we can do this:

1static_cast<int>(5.0)

More generally, if we want to convert SomeExpression into anSomeType, the pattern looks like this:

1static_cast<SomeType>(SomeExpression)

SomeExpression is anything that contains or returns data of type SomeType, or data that can be converted into data of SomeType.

The expression can be a literal value, as shown above; it might be a variable, it might be a call to a function; it might be a maths operation, and so on.

Here are some examples:

1static_cast<int>(20.0f);
2static_cast<int>(25.0);
3static_cast<int>(25.0 / 5);
4
5float SomeFloat { 10.f };
6static_cast<int>(SomeFloat);
7
8bool SomeBoolean { true };
9static_cast<int>(SomeBoolean ? 20 : 50.0 );
10
11double SomeFunction() { return 1.0; }
12static_cast<int>(SomeFunction());

Equally, the thing that is returned from a call to static_cast<int> is an integer, and can be used anywhere that an integer is valid:

1// Saving the result to a variable
2int MyInt1 { static_cast<int>(20.f) };
3int MyInt2 { static_cast<int>(25.0) / 5 };
4
5int Add(int x, int y) { return x + y; }
6
7// Passing the result to a function
8Add(
9  static_cast<int>(1.f),
10  static_cast<int>(2.0)
11);

These examples are heavily focused on using static_cast to convert to an int, but it can be used on any data type, including user-defined types:

1static_cast<float>(5.0);
2static_cast<Vector3>(142);
3static_cast<Monster>(5);

Static casting can also be used when working with pointers. We'll see that in more detail later in this chapter when we cover run-time polymorphism.

1bool IsDouble(double Number) { return true; }
2bool IsDouble(int Number) { return false; }
3
4IsDouble(static_cast<int>(5.0));

Another style of casting that is sometimes used is C-style casting. It has a slightly simpler syntax but, for reasons we'll cover later in this section, we should avoid using it.

If we had the following static_cast code:

1static_cast<int>(5.0);
2static_cast<bool>(SomeVariable);
3static_cast<Character>(SomeFunction());

Using C-style casting, it would look like this:

1(int)5.0;
2(bool)SomeVariable;
3(Character)SomeFunction();

1bool IsDouble(double Number) { return true; }
2bool IsDouble(int Number) { return false; }
3
4IsDouble((int)5.0);

C style casting was, predictably, inherited from the C language.

The original C language only had one form of casting, which was used to cover all use cases. C++ has several options, each covering a specific use case where casting is useful.

The C++ casts are identified by names like static_cast, dynamic_cast, and reinterpret_cast

These modern operators, sometimes called named casts, should be preferred over c-style casts. They clarify exactly what we're doing, and they perform additional checks to ensure what we're doing makes sense for that use case.

For example, if we attempt to cast the literal "Hi" to a number, that's almost certainly an error on our part. static_cast alerts us that this conversion doesn't make sense when we try to compile our code:

1#include <iostream>
2using namespace std;
3
4int main(){
5  cout << static_cast<int>("Hi");
6}

1error: 'static_cast': cannot convert from
2'const char [3]' to 'int'
3
4There is no context in which this conversion
5is possible

The equivalent C-style cast performs no such checks - it lets our program compile, and leaves us with unpredictable behavior:

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

12041494544

In this lesson, we covered:

• Static casting is a type of explicit conversion performed at build time, allowing for type conversion with minimal or no performance impact.
• The syntax static_cast<SomeType>(SomeExpression) is used for converting one data type to another, and it can be applied to literals, variables, function calls, and more.
• Static casting can check the conversion's validity at compile time, reducing runtime errors.
• While static casting is commonly used for primitive types, it's also applicable to custom types and pointers. We'll cover the pointer scenario later in the chapter.
• C-style casting, inherited from C, is simpler but less safe than static casting. It lacks compile-time checks which can lead to us accidentally introducing unpredictable behavior.