Understanding C++ Constant Member Functions: What Does ‘const’ Mean After a Function?

When learning C++, you may come across function declarations like this:

class Point {
  public:
    int GetX() const;
};

Then you might wonder: “What does this <span>const</span> at the end of the function mean? Why is it added?” 🤔

Actually, it represents a constant member function (<span>const</span> member function), let’s take a closer look.

What is a Constant Member Function

In simple terms, a constant member function promises not to modify the object’s data within the function.

For example:

class Point {
  public:
    Point(int x, int y) : x_(x), y_(y) {}

    int GetX() const { return x_; }
    int GetY() const { return y_; }

    void Move(int dx, int dy) { x_ += dx; y_ += dy; }

  private:
    int x_, y_;
};

Here, the <span>GetX()</span> and <span>GetY()</span> are both const member functions, meaning they do not change the <span>Point</span> object’s <span>x_</span> or <span>y_</span>.

Why Use Constant Member Functions

1. Protect Object Data: Ensures that the function does not accidentally modify member variables.
2. Allow const Objects to Call: If the object itself is <span>const</span>, only const member functions can be called:

int main() {
    const Point p(3, 4);
    std::cout << p.GetX() << ", " << p.GetY() << std::endl; // ✅ Can call
    // p.Move(1, 1); // ❌ Compilation error! const object cannot call non-const function
}

💡 Tip: If your function only reads data and does not modify the object, make it a habit to add <span>const</span>, as it is both safe and improves readability.

What Happens If You Modify Members in a const Function

Attempting to modify members will result in an error:

int GetX() const {
    x_ = 10; // ❌ Compilation error
    return x_;
}

If you really need to modify members within a const function, you can use <span>mutable</span>:

class Logger {
  public:
    mutable int log_count_;
  public:
    void log() const { log_count_++; } // ✅ mutable allows modification
};

Summary

• const Member Functions ensure that the function does not modify the object’s data
• const Objects can only call const member functions