How Do I Declare a Variable Inside a C++ Class?

#include <string>

class Player {
public: // We'll discuss this next!
    // Member variable declarations
    std::string username;
    int health;
    int score;
};

int main() {
    Player playerOne; // Create an object (instance) of the Player class
    playerOne.username = "Gladiator123";
    playerOne.health = 100;
    playerOne.score = 0;

    Player playerTwo;
    playerTwo.username = "RogueOne";
    playerTwo.health = 85;
    // ... and so on

    return 0;
}
    

protected

protected is a middle ground. Members are accessible within the class itself and by any classes that inherit from it (derived classes), but not from the outside world. It's useful in inheritance hierarchies.

Comparison of Access Specifiers

Specifier	Accessible from Same Class	Accessible from Derived Class	Accessible from Outside
public	Yes	Yes	Yes
protected	Yes	Yes	No
private	Yes	No	No

Let's fix our Player class using proper encapsulation:

#include <string>
#include <iostream>

class Player {
private:
    // Data is now private and protected
    std::string username;
    int health;
    int score;

public:
    // Public functions (methods) to interact with the data
    void setUsername(std::string newUsername) {
        username = newUsername;
    }

    std::string getUsername() {
        return username;
    }

    void takeDamage(int damage) {
        health -= damage;
        if (health < 0) {
            health = 0;
        }
    }

    int getHealth() {
        return health;
    }
};

int main() {
    Player playerOne;
    // playerOne.health = 50; // ERROR! Cannot access private member
    playerOne.setUsername("Gladiator123");
    playerOne.takeDamage(20);

    std::cout << playerOne.getUsername() << " has " << playerOne.getHealth() << " health.\n";
    return 0;
}
    

Now, the only way to change the player's health is through the takeDamage method. This allows us to add logic, like ensuring health never drops below zero. We've protected our object's state!

Initializing Member Variables: The Right Way

Just declaring a variable isn't enough; it needs a value. There are several ways to initialize member variables, and some are much better than others.

The Old Way: Assignment in the Constructor Body

A common beginner approach is to assign values inside the constructor's body.

class Player {
private:
    std::string username;
    int health;
public:
    Player(std::string name) {
        username = name; // Assignment
        health = 100;    // Assignment
    }
};
    

This works, but it's not ideal. For complex types, this is actually a two-step process: the member is first default-constructed, and then it's assigned a new value. This is inefficient.

The Better Way: Member Initializer List

The C++ way is to use a member initializer list. This syntax directly initializes the members before the constructor body is executed. It's more efficient and is the only way to initialize const members or reference members.

class Player {
private:
    std::string username;
    int health;
public:
    // Member Initializer List
    Player(std::string name) : username(name), health(100) {
        // Constructor body can now be empty or used for other logic
    }
};
    

The syntax is a colon : after the constructor signature, followed by a comma-separated list of `memberName(value)`.

The Modern Way (C++11+): In-Class Initializers

Since C++11, you can provide default values for your members directly where you declare them. This is clean, easy to read, and my personal preference for providing default state.

class Player {
private:
    std::string username = "Guest"; // In-class initialization
    int health = 100;               // In-class initialization
    int score = 0;
public:
    // Use a constructor to provide non-default values
    Player() = default; // Creates a Player with the default values

    Player(std::string name) : username(name) {
        // health and score will still get their default values (100 and 0)
        // We only need to initialize what's different.
    }
};
    

Rule of thumb: Use in-class initializers for common, fixed defaults. Use member initializer lists in constructors when the initial value depends on a constructor parameter.

Static Member Variables: Shared Data for All Objects

What if you want a variable that is shared by all objects of a class? For example, a counter to track how many Player objects have been created. This is what static member variables are for.

A static member exists only once, regardless of how many objects you create. It belongs to the class itself, not to any individual object.

Declaring a static member is a two-step process:

1. Declare it inside the class with the static keyword.
2. Define and initialize it outside the class, in your .cpp file. This actually allocates the memory for it.

// Player.h (Header File)
class Player {
public:
    static int playerCount; // Declaration

    Player() {
        playerCount++;
    }
};

// Player.cpp (Source File)
#include "Player.h"

int Player::playerCount = 0; // Definition and initialization

// main.cpp
#include <iostream>
#include "Player.h"

int main() {
    std::cout << "Initial players: " << Player::playerCount << '\n'; // Access via class name
    Player p1;
    Player p2;
    std::cout << "Players created: " << Player::playerCount << '\n';
    // Output:
    // Initial players: 0
    // Players created: 2
}
    

Since C++17, you can use inline static to initialize the variable directly in the header file, simplifying things for simple types: inline static int playerCount = 0;.

Constant Member Variables: const and constexpr

Sometimes you have a member variable that should be set once when the object is created and never change again. This is a job for const.

const Members

A const member variable must be initialized using the member initializer list. You cannot assign to it in the constructor body because by the time the body executes, the member is already considered constant.

#include <chrono>

class UserAccount {
private:
    const int userID;
    const std::chrono::system_clock::time_point creationDate;

public:
    UserAccount(int id) 
        : userID(id), creationDate(std::chrono::system_clock::now()) // MUST initialize here
    {
        // userID = id; // ERROR! Cannot assign to a const member.
    }
};
    

static const and constexpr Members

If you need a constant that is shared across all instances (a class-wide constant), you can combine static and const. For integral types (like int, bool, char), you can initialize it directly in the class.

class GameSettings {
public:
    static const int maxPlayers = 4; // OK for integral types
    // For modern C++, constexpr is even better
    static constexpr double gravity = 9.8;
};
    

constexpr indicates a true compile-time constant, which is generally preferred over static const where possible.

Best Practices for Declaring Class Variables

Let's wrap up with a quick summary of best practices:

• Default to private: Always make your member variables private to enforce encapsulation. Provide public member functions (getters/setters) for controlled access.
• Initialize Everything: Never leave a member variable uninitialized. This is a common source of bugs.
• Prefer In-Class Initializers: For C++11 and later, use in-class initializers (int value = 10;) to provide clear, default values.
• Use Member Initializer Lists: Use the constructor's initializer list for members that depend on constructor arguments, and for all const or reference members.
• Use static for Shared Data: If a piece of data belongs to the class as a whole and not to individual objects, make it static.
• Use const for Immutability: If an object's attribute should not change after creation, declare it const.

Conclusion

Declaring variables in a C++ class is more than just syntax; it's about designing the state and behavior of your objects. By moving from simple public declarations to a thoughtful approach using private members, proper initialization techniques, and modifiers like static and const, you take a huge step toward writing safer, more robust, and more maintainable code.

The concepts of encapsulation and proper state management are cornerstones of object-oriented programming. Master them, and you'll be well on your way to building complex and powerful C++ applications. Happy coding!