C++ Classes Refresher

Lesson Overview

Greetings! Today, we're revisiting C++ classes, the core building block of Object-Oriented Programming (OOP) in C++. Through hands-on examples, we'll revisit the fundamental concepts of C++ classes, including their structure, attributes, and methods.

C++ Classes Refresher

Let's begin with a refresher on C++ classes. Essential to OOP, C++ classes bundle relevant data and functions into compact units called objects. Consider a video game character, which is a typical example of a class instance, with specific attributes (such as health or strength) and methods (such as attack or defense). C++#include <iostream> #include <string> class GameCharacter { public: // Constructor GameCharacter(std::string name, int health, int strength) : name(name), health(health), strength(strength) {} // Method void attack(GameCharacter& other_character) { other_character.health -= this->strength; } // Attributes std::string name; int health; int strength; }; C++ classes facilitate the grouping of associated code elements, simplifying their management. Now, to better remind ourselves how the above example works, let's go through it step-by-step.

Structure of a C++ Class

A C++ class serves as a blueprint consisting of attributes and methods. While attributes represent data relevant to a class instance, methods are actions or functions that manipulate this data. Each class includes a constructor, which is used to define class attributes. An essential keyword within these methods is this, which represents the class instance. In object-oriented programming, it is needed to access the class's attributes and methods. When a new class instance is created, C++ automatically provides access to the instance through the this pointer, allowing each object to keep track of its own state and behaviors. C++#include <iostream> #include <string> class GameCharacter { public: // Constructor GameCharacter(std::string name, int health, int strength) : name(name), health(health), strength(strength) {} // Method void attack(GameCharacter& other_character) { other_character.health -= this->strength; } // Attributes std::string name; int health; int strength; }; GameCharacter character("Hero", 100, 20); // object or instance of the class #include <iostream> #include <string> class GameCharacter { public: // Constructor GameCharacter(std::string name, int health, int strength) : name(name), health(health), strength(strength) {} // Method void attack(GameCharacter& other_character) { other_character.health -= this->strength; } // Attributes std::string name; int health; int strength; }; GameCharacter character("Hero", 100, 20); // object or instance of the class

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Class Attributes

Attributes in C++ classes hold data associated with each class instance. For example, in our GameCharacter class, name, health, and strength are attributes. You can access a class attribute using the object of the class, followed by a dot (.), and then the attribute name.

Attributes are initialized using a constructor, and one concise way to do this is through an initializer list. The initializer list is part of the constructor but it appears before the constructor's body. This approach is beneficial for initializing attributes efficiently, especially for constant (const) members or reference members, which must be initialized at the time of their creation.

C++

#include <iostream>
#include <string>

class GameCharacter {
public:
    // Constructor using an initializer list
    GameCharacter(std::string name, int health, int strength)
        : name(name), health(health), strength(strength) {} // initializer list (followed by an empty body)

    // Attributes
    std::string name;
    int health;
    int strength;
};

int main() {
    GameCharacter character("Hero", 100, 20);  // instance of the class
    std::cout << character.name << std::endl;  // prints: Hero
    std::cout << character.health << std::endl;  // prints: 100
    std::cout << character.strength << std::endl;  // prints: 20
    return 0;
}

#include <iostream>
#include <string>

class GameCharacter {
public:
    // Constructor using an initializer list
    GameCharacter(std::string name, int health, int strength)
        : name(name), health(health), strength(strength) {} // initializer list (followed by an empty body)

    // Attributes
    std::string name;
    int health;
    int strength;
};

int main() {
    GameCharacter character("Hero", 100, 20);  // instance of the class
    std::cout << character.name << std::endl;  // prints: Hero
    std::cout << character.health << std::endl;  // prints: 100
    std::cout << character.strength << std::endl;  // prints: 20
    return 0;
}

In the above example, the colon (:) after the constructor indicates the beginning of the initializer list, which initializes the class attributes with the provided arguments. Attributes differentiate one class instance from another and store the state of the instance.

Class Methods

A class also contains methods - actions or functions that manipulate the data in the class. For example, the attack method in our GameCharacter class simulates an attack by one game character on another.

C++

#include <iostream>
#include <string>

class GameCharacter {
public:
    // Constructor: defines class attributes
    GameCharacter(std::string name, int health, int strength)
        : name(name), health(health), strength(strength) {}

    // Method
    void attack(GameCharacter& other_character) {
        other_character.health -= this->strength;  // modifies 'other_character's health attribute
    }

    // Attributes
    std::string name;
    int health;
    int strength;
};

int main() {
    GameCharacter character_1("Hero", 100, 20);   // First instance of GameCharacter
    GameCharacter character_2("Villain", 80, 15);  // Second instance

    std::cout << character_2.health << std::endl;  // prints: 80
    character_1.attack(character_2);  // character_1 attacks character_2
    std::cout << character_2.health << std::endl;  // prints: 60, health decreased after attack
    return 0;
}

#include <iostream>
#include <string>

class GameCharacter {
public:
    // Constructor: defines class attributes
    GameCharacter(std::string name, int health, int strength)
        : name(name), health(health), strength(strength) {}

    // Method
    void attack(GameCharacter& other_character) {
        other_character.health -= this->strength;  // modifies 'other_character's health attribute
    }

    // Attributes
    std::string name;
    int health;
    int strength;
};

int main() {
    GameCharacter character_1("Hero", 100, 20);   // First instance of GameCharacter
    GameCharacter character_2("Villain", 80, 15);  // Second instance

    std::cout << character_2.health << std::endl;  // prints: 80
    character_1.attack(character_2);  // character_1 attacks character_2
    std::cout << character_2.health << std::endl;  // prints: 60, health decreased after attack
    return 0;
}

Examples of C++ Classes, Attributes, and Methods

To deepen our understanding of C++ classes, let's explore another example where we build a basic BankAccount class. This class will demonstrate how we can model real-world entities using object-oriented programming by defining attributes like an account holder's name and balance and methods for depositing and withdrawing money.

C++

#include <iostream>
#include <string>

class BankAccount {
public:
    // Constructor with a default balance of 0
    BankAccount(std::string holder_name, double balance = 0)
        : holder_name(holder_name), balance(balance) {}

    // Method to deposit money
    void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
            std::cout << amount << " deposited. New balance: " << balance << std::endl;
        } else {
            std::cout << "Deposit amount must be positive." << std::endl;
        }
    }

    // Method to withdraw money
    void withdraw(double amount) {
        if (0 < amount && amount <= balance) {
            balance -= amount;
            std::cout << amount << " withdrawn. Remaining balance: " << balance << std::endl;
        } else {
            std::cout << "Insufficient balance for the withdrawal or amount is not positive." << std::endl;
        }
    }

    // Attributes
    std::string holder_name;
    double balance;
};

int main() {
    BankAccount account("Alex", 1000);  // An account with an initial balance of 1000

    // Perform some transactions
    account.deposit(500);  // Deposit money
    account.withdraw(200);  // Withdraw money
    std::cout << "Final balance in " << account.holder_name << "'s account: " << account.balance << std::endl;
    return 0;
}

#include <iostream>
#include <string>

class BankAccount {
public:
    // Constructor with a default balance of 0
    BankAccount(std::string holder_name, double balance = 0)
        : holder_name(holder_name), balance(balance) {}

    // Method to deposit money
    void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
            std::cout << amount << " deposited. New balance: " << balance << std::endl;
        } else {
            std::cout << "Deposit amount must be positive." << std::endl;
        }
    }

    // Method to withdraw money
    void withdraw(double amount) {
        if (0 < amount && amount <= balance) {
            balance -= amount;
            std::cout << amount << " withdrawn. Remaining balance: " << balance << std::endl;
        } else {
            std::cout << "Insufficient balance for the withdrawal or amount is not positive." << std::endl;
        }
    }

    // Attributes
    std::string holder_name;
    double balance;
};

int main() {
    BankAccount account("Alex", 1000);  // An account with an initial balance of 1000

    // Perform some transactions
    account.deposit(500);  // Deposit money
    account.withdraw(200);  // Withdraw money
    std::cout << "Final balance in " << account.holder_name << "'s account: " << account.balance << std::endl;
    return 0;
}

This example further illustrates how classes effectively encapsulate data (attributes) and functionalities (methods), enabling us to mimic real-life scenarios. Here, the BankAccount class allows the creation of objects representing bank accounts, emphasizing the powerful organizational benefits of using classes in C++.

C++ Classes Refresher

Lesson Overview