Structs and Aggregate Initialization

In some of our class examples, we suggested that our objects should have properties like WorldPosition - where that character currently exists in the world.

In 3D environments, this is represented as three separate numbers, or coordinates, typically called x, y, and z

We could store this as 3 separate variables. But it is usually much better to package these coordinates together, so they can be used and transferred as a single object.

This means we need to create a new custom type of data.

Creating Structs

We've already seen how to define a new data type using a class, but there is an alternative - something called a structure, or struct:

1struct Vector3 {
2  float x;
3  float y;
4  float z;
5}

1auto Ability {
2  int MinDamage;
3  int MaxDamage;
4  float CritChance;
5};

1struct Ability {
2  int MinDamage;
3  int MaxDamage;
4  float CritChance;
5};

1typedef Ability {
2  int MinDamage;
3  int MaxDamage;
4  float CritChance;
5};

Structs vs Classes (Technical)

You may be thinking this problem could also be solved by classes. This is completely true - Vector3 could indeed be a class.

In C++, structs and classes are almost identical. The only difference between a struct and a class is that, by default, members of a struct are public whilst in a class, they are private.

Aside from that, there is no difference - we create and use structs in the same way we do classes. Structs can have functions, constructors, destructors, and more. and everything else that a class has.

Everything we have learned (and will learn in the future) about classes also applies to structs.

Structs vs Classes (Semantic)

Even though structs and classes are technically almost identical, the C++ community still attaches semantic differences to the two concepts.

The general sentiment is that structs are for creating simpler types, whilst classes are for creating more powerful types.

Google's style guide offers a good example, and many developers/companies have a similar approach:

Moreover, the difference between classes and structs may become slightly more important when working within the context of other ecosystems, such as a game engine.

For example, in Unreal, structs have legitimate technical limitations that effectively enforce the "structs are for simple things" convention.

Aggregate Initialization

Aggregate initialization is a feature that simplifies the process of initializing simple objects.

It allows us to initialize the members of a struct or an array directly without needing to explicitly define a constructor.

Consider our earlier Vector3 struct:

1struct Vector3 {
2  float x;
3  float y;
4  float z;
5};

In a typical scenario, you would need to define a constructor to initialize these values. However, with aggregate initialization, you can directly assign values to x, y, and z when creating an instance of Vector3. Here's what it looks like:

1struct Vector3 {
2  float x;
3  float y;
4  float z;
5};
6
7int main() {
8  Vector3 Position {1.9, 2.6, 0.3};
9}

In this example, Position is an instance of Vector3 with x, y, and z initialized to 1.9, 2.6, and 0.3 respectively.

Aggregate initialization is not always available. We cover it in detail in the advanced course, but for now, we should note that it is more likely to be an option when our types are simple.

As such, if we’re adopting the convention of structs being for simple types, aggregate initialization is much more likely to be available to instantiate structs than classes.

With a type that uses more advanced features - such as private sections - aggregate initialization is less likely to be an option, and we need to go back to defining an appropriate constructor manually.

Summary

In this lesson, we delved into the concept of structs in C++, exploring their technical and semantic differences from classes. Here are the key takeaways:

• Structs offer a simpler alternative to classes for bundling data together.
• By default, members of a struct are public, unlike in a class where they are private. This is the only technical difference between the two.
• Structs are generally used for passive objects that carry data, without complex behaviors or functionalities.
• Aggregate initialization allows for the simple and direct assignment of values to the members of a struct, enhancing code brevity and clarity.
• The concept of vectors, specifically Vector3, was introduced as a fundamental type in graphics applications, demonstrating a practical use of structs.

Preview of the Next Lesson: Operator Overloading

Previously, we've seen how built-in objects like int and bool allowed us to use operators like + and >= to interact with them.

1int SomeInt { 2 };
2int AnotherInt { SomeInt + 5 };
3bool SomeBool { AnotherInt >= 10 };
4bool AnotherBool { !MyBoolean };

It would be useful if we had a way to define operators for our custom types too. For example, we'll need the ability to add two of our vectors together.

We could define a function on our class or struct to facilitate that. It could allow us to add vectors together by doing something like this:

1MyFirstVector.Add(MySecondVector);

But our code would be more expressive if we could just do this instead:

1MyFirstVector + MySecondVector;

In the next lesson, we can see how we can update our classes and structs to make these types of interactions possible.

Next Lesson

Operator Overloading

This lesson introduces operator overloading, a fundamental concept to create more intuitive and readable code by customizing operators for user-defined types

ContinueView Course