C++ Classes: Define Objects, Members, and Methods

What a Class Is

A class is a blueprint for a custom type that bundles data (member variables) and behavior (member functions) into one unit. Where the built-in types like int and double describe single values, a class lets you model a whole concept - a bank account, a 2D point, a player - as a single value you can pass around.

You have already used classes without defining any: std::string and the vector container are classes from the standard library. Calling name.length() or v.push_back(3) is calling a member function on an object. Now you will build your own types the same way, then move on to constructors for initializing them.

Defining a Class and Creating Objects

A class definition lists its members between braces and ends with a semicolon - forgetting that trailing ; is one of the most common beginner errors. Each object you create from the class gets its own copy of the member variables.

#include <iostream>
#include <string>
using namespace std;

class Dog {
public:
    string name;   // member variable
    int age;       // member variable

    void bark() {  // member function
        cout << name << " says woof!" << endl;
    }
};

int main() {
    Dog rex;            // create an object (instance)
    rex.name = "Rex";   // set members with the . operator
    rex.age = 4;

    Dog luna;           // a second, independent object
    luna.name = "Luna";

    rex.bark();
    luna.bark();
    return 0;
}

rex and luna are two separate objects. Changing rex.name does not touch luna.name - each object holds its own data. You reach a member with the dot operator . on an object (or -> when you have a pointer to one).

public vs private

By default, everything in a class is private: only the class's own member functions can touch it. The public: label opens members up to outside code. This split is the heart of encapsulation - you expose a safe interface and hide the internal data so it can't be put into an invalid state.

#include <iostream>
using namespace std;

class Counter {
private:
    int count = 0;            // hidden - outsiders can't touch it

public:
    void increment() {        // the safe interface
        count++;
    }
    int value() const {       // const: this function won't modify the object
        return count;
    }
};

int main() {
    Counter c;
    c.increment();
    c.increment();
    cout << "Count: " << c.value() << endl;

    // c.count = 100;   // ERROR: 'count' is private
    return 0;
}

Because count is private, no caller can sneak in a negative or nonsensical value - they must go through increment(). The const after value()'s parameter list promises the function won't modify the object, which lets you call it on const objects and signals intent to readers.

Declaration vs. Definition of Methods

For small classes, defining methods inline (as above) is fine. For larger ones, it's common to declare methods inside the class and define their bodies outside, using the ClassName::method scope syntax. This keeps the class definition readable as a summary of the interface.

#include <iostream>
#include <string>
using namespace std;

class Rectangle {
public:
    double width;
    double height;

    double area() const;        // declaration only
    void describe() const;      // declaration only
};

// Definitions live outside, qualified with Rectangle::
double Rectangle::area() const {
    return width * height;
}

void Rectangle::describe() const {
    cout << width << " x " << height
         << " = " << area() << endl;   // can call other members directly
}

int main() {
    Rectangle r;
    r.width = 3.0;
    r.height = 4.0;
    r.describe();
    return 0;
}

The Rectangle:: prefix tells the compiler which class the function belongs to. Inside such a definition you still refer to members by their bare names (width, area()) - the compiler knows they belong to the object the method was called on.

The this Pointer

Inside any non-static member function, this is a pointer to the object the function was invoked on. You usually don't need it, since a bare member name already refers to the current object. It earns its keep when a parameter shadows a member - they share a name - and you must disambiguate.

#include <iostream>
using namespace std;

class Point {
public:
    int x = 0;
    int y = 0;

    void setX(int x) {     // parameter 'x' shadows member 'x'
        this->x = x;       // this->x is the member; x is the parameter
    }

    void print() const {
        cout << "(" << x << ", " << y << ")" << endl;
    }
};

int main() {
    Point p;
    p.setX(7);
    p.print();
    return 0;
}

Without this->, writing x = x; inside setX would assign the parameter to itself and leave the member untouched - a silent bug. this->x makes it unambiguous. Many codebases avoid the problem entirely by naming parameters differently (e.g. setX(int newX)), but you will see this-> constantly in real code.

Common Mistakes

A handful of class traps catch people repeatedly:

• Missing the closing semicolon. A class definition ends with };. Drop the ; and you get a flood of confusing errors pointing at whatever comes after the class, not at the class itself.
• Forgetting to initialize members. Built-in members like int and double are not zeroed automatically. Reading an uninitialized member is undefined behavior. Give members default values (int count = 0;) or initialize them in a constructor.
• Accessing private members from outside. c.count = 5; on a private member is a compile error - go through a public method instead. This is the encapsulation working as intended.
• Confusing the class with an object. Dog.bark(); is wrong - Dog is the type. You call methods on objects: rex.bark();.

// Uninitialized member - reading 'age' is undefined behavior:
class Cat {
public:
    int age;            // no default value
};

Cat c;
std::cout << c.age;     // garbage value, not 0

Next: Constructors

Setting each member by hand after creating an object - rex.name = ...; rex.age = ...; - is tedious and easy to forget, which is exactly how you end up with uninitialized members. The next page covers constructors: special functions that run automatically when an object is created, letting you guarantee every object starts in a valid state with a clean one-line Dog rex("Rex", 4); syntax.