Objects, Variables and Types

One of the first things you'll hear when it comes to programming is the concept called Object-Oriented Programming. This is a major feature of C++, and it is a commonly adopted pattern for building complex projects.

When designing object-oriented programs, we think of our code in terms of objects. Objects are just a digital representation of something our software is trying to represent, or simulate. They're a way to organize our project into distinct entities.

• If we were making banking software, we might be creating and managing objects that represent customers and currencies.
• For a library, it might be books and employees.
• For video games, it could be dragons, weapons, and magical spells.

This approach not only simplifies the design of complex software but also makes it easier to maintain as the project gets more and more complex.

For instance, in object-oriented design, a game would treat each player, enemy, and piece of the environment as distinct objects. This modular structure mirrors real-world interactions, making our software more intuitive and aligned with how we naturally perceive the world.

A way to identify what objects our software might have is to start with a plain language description of what we're building. For example:

In Mythic Quest, our heroes enter dungeons and kill monsters to collect magical items

By picking out nouns from this description, we can identify some of the types of objects we might want to be creating. This might be things such as:

• Heroes
• Dungeons
• Monsters
• Items

Just like objects in the real world, objects in programming have properties and actions that they can perform.

In programming, we often call these object properties variables, and the actions that the objects can perform are called functions.

For the next few lessons, we'll focus on variables. We'll look at functions in the next chapter.

Variables

Variables are pieces of data that help describe the current state of our object. Let’s take one of our monsters as an example. Some things we might need to keep track of for our monster are:

• What is its name?
• Is it alive?
• How much health does it have?
• How much armor/damage resistance does it have?
• Where is it currently located in the world?
• What weapon does it have equipped?

Answers to these questions would be stored as variables on each monster object.

Data Types

We can notice from the list above that there are different types of data we might need to store. For example:

• Whether the monster is alive will only have two possible values - it is either true or it is false
• For information about its health, we might expect that value to be a number.
• For the name, it might be a string of alphabetic characters.
• To store information about what weapon the monster has equipped, our variable might need to store another object entirely - a Weapon object, with its own set of variables.

For now, the key point is that each variable stores data of a specific type. When creating programs, we need to be aware of the type of data that is being stored in the variables we’re working with. Some common data types in C++ include:

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

Variable Names

Once we identify what type of data we want to store in our variable, we next need to give our variable a name - an identifier that we will use in our code.

There are some restrictions to these names. The most notable restriction is that an identifier cannot contain a space, and it cannot start with a number. But beyond those restrictions, we can mostly call our variables whatever we want.

However, it is strongly recommended that we choose sensible, descriptive names for our variables.

For example, if a variable is intended to store a character's current amount of health, a name like Health would be much better than a name like MyVariable or x.

There's no technical reason why we can't call our variable things like MyVariable or x. However, once our code gets more complex, it can be very difficult to follow what’s happening if our variables do not have meaningful names.

When we want to use multiple words to describe our variable, there are some conventions to bypass the inability to use spaces. Common approaches include using underscores or capitalization, for example: currentHealth, CurrentHealth, or Current_Health.

Let's revisit our requirements for our monster objects, and map our variables up to a data type and a name.

The first four data types are things C++ can provide us with. Simple types like numbers and strings are included with the language by default because they’re useful across a wide range of programs.

Data types like position and weapon are much more specific to our needs. As such, they're not included as part of the language. However, C++ gives us the ability to add our own data types, specific to the needs of our project. We'll see how to do that in Chapter 3.

Until then, we will just use simple booleans, integers, floating-point numbers, and strings, so we can establish the basics.

Summary

In this lesson, we introduced the basic concept of Object-Oriented Programming, covering:

• Objects in C++: Learned as digital representations of entities, essential for organizing complex software.
• Variables and Functions: Introduced as properties and actions of objects.
• Data Types: Introduced bool, int, float, char, and string, highlighting C++ as a strongly typed language.
• Variable Naming: Discussed the importance of meaningful names for clarity in code.

What's Next?

In the next lesson, we’ll put this knowledge to practical use. We will:

• Dive into creating and updating variables in code
• Understand how data types affect variable declaration
• Introduce comments, allowing us to add plain-language documentation to our code

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