Abstraction and Classes

In the previous chapter, we discussed how we can approach programming by thinking about objects - things that exist within the world our program is trying to simulate.

For example, were we making a fantasy game, we might be simulating objects like monsters, weapons, and magical spells.

We saw how we have two fundamental tools to simulate an object:

• variables, that represent the current state of the object
• functions, that allow the object to perform actions

1// Variable
2int Health{150};
3
4// Function
5void TakeDamage(int Damage){
6  Health -= Damage;
7}

Abstraction

Our game might have thousands of objects. We don't want to define tens of thousands of variables and functions to manage this.

Instead, we want to write code that can apply to large sets of these objects. For example, maybe 100 of our objects will be monsters that the player can fight.

All the monster objects in our game likely share a lot of similar characteristics - for example, they may all have Health variables, and they all have TakeDamage() functions.

So, rather than writing code for 100 individual monster objects, we write code that works for all monsters, which they can then share.

This process of generalization, where we take specific objects and group them into more general categories is called abstraction

Built-in Types

We already saw examples of abstraction in the built-in types we've been using. For example, int is an abstraction.

C++ compilers didn't have to define code for every individual integer, like 3, 42, and 53,195. Rather, they created an abstract concept of what an integer is, and the things an integer can do.

All integer objects then share those capabilities - like the ability to be incremented using the ++ operator or be logged to the terminal using the << operator.

The int data type is what provides that abstraction. Similarly, bool provides an abstraction for true and false values, whilst string abstracts blocks of text.

User-Defined Types

Just as C++ provides some built-in types that are useful to a wide range of programs:

1int Level;
2bool isAlive;
3string Name;

So too does it give us the ability to create user-defined types. These are types that we can set up to generalize the categories of objects that will exist in our specific project:

1Monster Goblin;
2Weapon IronSword;
3Spell Fireball;

A class is the main way we define a custom type. To create a user-defined type, such as Monster, we would create a class like this:

1#include <iostream>
2using namespace std;
3
4class Monster {
5public:
6  // Class code here
7};
8
9int main() {
10  // We can now create Monsters
11  Monster Goblin;
12}

We describe the meaning of the public: line later in this chapter. For now, let's just ensure it is included at the top of our classes.

1class Weapon {
2public:
3};

1class Weapon() {
2public:
3};

1class Weapon (
2public:
3);

Classes vs Objects

There is often some confusion at this point about what differentiates an object from a class. This will become clear as we start creating classes and objects in future lessons, but let's discuss it briefly here.

The English definition of class is: a category of things having some property or attribute in common

It means the same thing in programming. A class defines an abstract category of things that are, in some way, similar. The things within that category are objects.

Consider this example.

1Monster Bonker;
2Monster Basher;

Here, Monster is a class. It is not a specific monster - it is an abstract idea of what it is to be a monster. It includes a description of what variables and functions all monsters have.

A class also grants the ability to create new objects of that class. Above, we're using that ability to create two specific monsters. Bonker and Basher are both objects.

1class Weapon {
2public:
3
4}

Class Members

To provide objects of our classes with the ability to store their state and perform actions, we need to define those variables and functions as part of our class.

Variables and functions that belong to a class are sometimes referred to as class members.

The syntax we use for class members is identical to what we're familiar with in the previous chapter. We just place our variables and functions within the curly braces of a class definition.

For now, we should also ensure it is below the public: line within our class:

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

The Member Access Operator

Once we've created an object from our class, we will want to access the variables and functions that are granted to our object by the class.

We do that through the member access operator, which is a simple period: .

For example, accessing the Health variable of a Monster object would look like this:

1Monster Bonker;
2Bonker.Health;

Calling a function would look like this:

1Monster Bonker;
2Bonker.TakeDamage();

Below, we show these concepts in a simple program:

1#include <iostream>
2using namespace std;
3
4class Monster {
5public:
6  int Health{150};
7
8  void TakeDamage(int Damage){
9    Health -= Damage;
10  }
11};
12
13int main(){
14  Monster Bonker;
15  cout << "Bonker Health: " << Bonker.Health;
16  Bonker.TakeDamage(25);
17  cout << "\nBonker Health: " << Bonker.Health;
18};

1Bonker Health: 150
2Bonker Health: 125

We can use a class variable in the same way we use any other variable of that same type. Above, Bonker.Health is an int, so we can use it like any other int. For example, we can:

• Pass it as an argument to a function
• Copy its value to a new variable
• Use the ++ to increment it
• Use the != to compare it to another number, generating a boolean result

1class Weapon {
2public:
3  int Damage { 50 };
4};
5
6Weapon IronSword;

1#include <iostream>
2using namespace std;
3
4class Monster {
5public:
6  int Health{100};
7};
8
9int main(){
10  Monster Bonker;
11  Monster Basher;
12  cout << "Bonker Health: " << Bonker.Health;
13  cout << "\nBasher Health: " << Basher.Health;
14
15  Bonker.Health = 50;
16  cout << "\nBonker Health: " << Bonker.Health;
17  cout << "\nBasher Health: " << Basher.Health;
18};

1Bonker Health: 100
2Basher Health: 100
3Bonker Health: 50
4Basher Health: 100

Class Function Prototypes

In the previous chapter on forward declarations, we introduced how a function can be declared and defined in different places in our code.

Forward Declarations

Understand what function prototypes are, and learn how we can use them to let us order our code any way we want.

We can apply this same technique to class functions too, should we need to. Within our class definition, we provide the prototype for our class function:

1class Monster {
2public:
3  int Health { 150 };
4  // Declaration
5  void TakeDamage(int Damage);
6};

We can then provide the definition elsewhere in our code.

The only difference is that, when we're defining a class function, we need to additionally provide the class name. We do that by using the ClassName::FunctionName pattern.

For example, to define the TakeDamage function for the Monster class, we would do this:

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

This might seem quite weird but, for reasons we'll cover later, a lot of C++ code is written this way. We'll stick with declaring and defining functions together in this course, but for now, just note that this separation is possible.

Summary

The key points covered in this lesson were:

• Introduced the concept of classes as fundamental to object-oriented programming.
• Explained abstraction as the process of generalizing specific objects into broader categories, allowing for more efficient and manageable code.
• Discussed built-in types in C++ like int, bool, and string, showcasing them as examples of abstraction.
• Covered the creation of user-defined types through classes, enabling the definition of custom objects specific to a project's needs.
• Clarified the difference between a class and an object, with a class being an abstract category and an object being an instance of that class.
• Introduced the concept of instantiating a class to create objects, and the use of the member access operator (.) to interact with an object's variables and functions.
• Demonstrated how to define class members, including both variables and functions.
• Provided insights into class function prototypes, showing how functions can be declared within a class and defined elsewhere.

Preview of Next Lesson: Access Modifiers

In the upcoming lesson, we'll explore access modifiers, which control the visibility and accessibility of class members.

• We'll explore the public: modifier, as seen in this lesson, and introduce other modifiers
• We'll see how public members can be accessed from anywhere, while private members are only accessible within the class itself.
• We'll see how this lets us achieve encapsulation - an important goal to keep complex projects manageable and pleasant to work on.

Free and Unlimited Access

Professional C++

Unlock the true power of C++ by mastering complex features, optimizing performance, and learning expert workflows used in professional development

View Course