Welcome to Programming and Data Structures

If we make the member variables of a class private, they are part of its implementation and outside code cannot access them directly. So how can outside code get or set the values of those member variables?

To allow for that, we need to provide an interface through which outside code can access those member variables. We do this by declaring member functions (also sometimes called methods) that are part of the class and have access to the private member variables. We then make those functions public so that outside code can call them.

class Point {
// Interface
// public member functions
public:
    double getX() {
        return m_x;
    }

// Implementation
// private member variables
private:
    double m_x;
    double m_y;
}

Note that the function getX is in a public block. Then look closely at the code inside the function getX(). What looks odd?

There is no declaration of m_x in this function! It is not declared as a parameter, nor is it declared as a local variable. It is the member variable of Point named m_x. getX is a part of a Point object, and every object has a m_x, so it is assumed that m_x refers to the member variable of “the current object”.

To call a member function, we always need to call it on a particular object:

p1.getX();
p2.getX();

Trying to use a member function without an object is a syntax error. There is no getX() function, there is only the getX() function that is a member of the Point class. (Point::getX() is the full name of this function - “the getX that is a part of Point”.)

The fact that we call the function on a particular Point is what allows the function to know which object’s m_x to return.

Run this Codelens sample. You can ignore the code on lines 8-11 for now. But pay special attention each time it enters the getX function. When it does so, you will see a stack frame for Point::getX() and in that stack frame, you will see a variable called this that points at the object that is running the code. During the first call to Point::getX(), it will point to p1 since we called p1.getX() on line 23. Then, on line 26 when we call p2.getX(), this will be pointing at p2.

A hand drawn memory diagram might look like this:

The code in main is not allowed to directly access the private member variable m_x of the Point. But it can politely ask the Point to give it the value by calling a public member function getX(). The getX() function, as a member of the class, has access to the private information. Thus, we are providing an interface (public functions) so outside code can interact with the implementation (private variables) in a controlled way.

Currently, the interface does not allow outside code to change the m_x variable. From main, we can call getX() but there is no public member function that allows us to change it.

class Color {
private:
    int m_red, m_green, m_blue;
public:
    int getRed() {
        return m_red;
    }
};

int main() {
    Color c1;
    Color c2;
    c1.getRed();
}