Creating C++ Classes

Lets create our first C++ class!

The basic structure of a class is this:

1class Monster {
2public:
3// Class code here
4};
5

We use the class keyword, we give our class a name, eg Monster, and we open a set of braces - { and } to contain our class code.

Within the braces, we add the public: keyword, and then put our class code below it.

The meaning of public: will be discussed in more detail in the next lesson.

For now, lets just ensure we include it. Our class code should be between the public: and the closing brace }.

Class Members

The "members" of a class are the variables and functions within that class. They are created in the same way we have seen in the past, as demonstrated in the below example:

1class Monster {
2public:
3  // a variable
4  int Health { 150 };
5
6  // a function
7  void TakeDamage(int Damage) {
8    Health -= Damage;
9  }
10};
11

For the remaining of the code samples in this lesson, assume this class is defined as above.

Creating Objects from Classes

Now that we have our class created, we are able to use it to create Monster objects. A class is, in essence, the blueprint for how to create objects of a certain type.

In one of the first lesson of the course, we saw how we could create an integer:

1int MyInt;
2

In the above example, int is the type of data. It lets the compiler know what class to use for our new variable.

MyInt is the name of the variable.it is how we will identify this specific object in our code.

The syntax is exactly the same for our custom data types. The below code gives examples on how we can create a new Monster object, called Harry:

1Monster Harry;
2

After running this code, we have a new variable, that has a type of Monster and a name of Harry.

1class Car {
2public:
3  int Speed { 50 };
4}
5

The Member Access Operator

Once we have an object of the Monster type, the member access operator gives us access to the underlying variables and functions that the object has, by virtue of it being a Monster.

The member access operator is the period character .

1Monster Harry;
2Harry.Health; // 150
3Harry.TakeDamage(50);
4Harry.Health; // 100
5

Once we gain access to those variables and functions using the . operator, we can treat them exactly like we would with any other variable of that type.

A variable that is part of an object can be used and manipulated like any other variable we've seen. For example, if we had an integer variable on a class:

• It can be updated using operators like =, ++, and *=.
• It can be used in mathematical operations like + and /.
• It can generate booleans using operators like <= and ==
• It can be copied to a different variable.
• It can be passed as an argument to functions that expect integers.
• It can be returned from functions that return integers

1Monster Harry;
2Harry.Health = 100;
3Harry.Health += 100;
4
5int HarryHealth { Harry.Health };
6bool HarryIsHealthy { Harry.Health > 50 };
7
8int Add(int x, int y) {
9  return x + y;
10}
11Add(Harry.Health, 100);
12

1class Car {
2public:
3  int Speed { 50 };
4}
5
6Car MyCar;
7

Implementing Functions Separately using ::

The above example defined our class function at the same time we define our class. There is another way of doing this. We can define the prototype of the function within the class, and provide the implementation separately, elsewhere.

1class Monster {
2public:
3  int Health { 150 };
4  // the prototype
5  void TakeDamage(int Damage);
6};
7
8// the implementation
9void Monster::TakeDamage(int Damage) {
10  Health -= Damage;
11}
12

Note the addition of Monster:: before the function name in the above example. When implementing functions for a class from outside the { and } associated with that class, the ClassName:: is necessary.

The addition of Monster:: tells the C++ compiler that we are providing the implementation of a function that was declared in the Monster class.

For now, we'll continue to use the first method where we define the whole function as part of the class. I've included the second example as it's actually more commonly used, so it will crop up a lot when looking at other people's code.

The benefit of the second method is that it allows the implementations of class functions to be provided in a completely different place to the class itself - even in a different file.

This is useful for bigger projects, and a pattern we will be a adopting ourselves soon. But for now, we should just keep it simple.