What `const` Means at the End of a Member Function in C++

By the end of this page, you will understand what a const member function is in C++, why const at the end of a method matters, how it changes the type of this, and when you should use it. You will also see examples, common mistakes, and how this concept appears in real C++ codebases.

In C++, when const appears after a member function declaration, it means the function is a const member function.

class Example {
public:
    int getValue() const;
};

This tells the compiler that the function does not modify the object's observable state.

What it really means

Inside a non-static member function, C++ automatically passes a hidden pointer called this, which points to the current object.

• In a normal member function, this is effectively:

Example* const this;

• In a const member function, this becomes:

const Example* const this;

That means inside the function:

• you cannot modify data members of the object
• you cannot call non- member functions on the same object

Think of an object like a book in a library.

• A non-const member function is like writing notes in the book.
• A const member function is like reading the book without changing it.

If a function ends with const, you are telling the compiler:

"This function only reads from the object. It does not edit it."

Another useful mental model:

• int getAge() const = asking a question
• void setAge(int x) = changing something

So in practice:

• getters are usually const
• setters are usually not const

The compiler acts like a strict librarian: if you said a function is read-only, it will stop you from changing the object inside that function.

Basic syntax

class Person {
public:
    int getAge() const;
    void setAge(int value);

private:
    int age;
};

Here:

• getAge() const promises not to change the object
• setAge(int value) is allowed to change the object

Example implementation

#include <iostream>
using namespace std;

class Person {
public:
    Person(int a) : age(a) {}

    int getAge() const {
        return age;
    }

    void setAge( value) {
        age = value;
    }

:
     age;
};

{
    ;
    cout << p.() << ;

    p.();
    cout << p.() << ;
}

Traceable example

#include <iostream>
using namespace std;

class Counter {
public:
    Counter(int v) : value(v) {}

    int getValue() const {
        return value;
    }

private:
    int value;
};

int main() {
    const Counter c(10);
    cout << c.getValue() << '\n';
}

Step by step

1. const Counter c(10);

A Counter object is created with value = 10.

Because c is declared as const, you can only call const member functions on it.

Read-only accessors

A very common use is getter functions:

std::string getName() const;
int size() const;
bool empty() const;

These functions inspect an object without changing it.

Working with const references

Large objects are often passed by const reference to avoid copying:

void printUser(const User& user) {
    std::cout << user.getName() << '\n';
}

For this to work, getName() must be a const member function.

Standard library style

The C++ standard library uses const member functions heavily:

• std::string::size() const

In real C++ projects, trailing const is part of writing const-correct APIs.

Common patterns

Getters are usually const

class Config {
public:
    std::string getHost() const;
    int getPort() const;
};

Validation helpers are const

class Email {
public:
    bool isValid() const;
};

Query methods are const

class Buffer {
public:
    std::size_t size() const;
    bool empty() const;
};

1. Confusing return-type const with member-function const

These are different:

const char* foo() const;

• const char* applies to the returned pointer target
• trailing const applies to the object

A beginner may think they mean the same thing, but they do not.

2. Forgetting to mark getters as const

Broken example:

class User {
public:
    int getId() {
        return id;
    }

private:
    int id;
};

void printUser(const User& u) {
    // u.getId(); // compile error
}

Fix:

class  {
:
    {
         id;
    }

:
     id;
};

Trailing const vs other uses of const

Const member function vs non-const member function

Quick rule

ReturnType functionName() const;

Trailing const means:

• the function does not modify the object
• it can be called on const objects
• inside the function, this is treated like a pointer to const

Common examples

int size() const;
bool empty() const;
std::string name() const;
operator int() const;

Your example

class foobar {
public:
    operator int() ;
    ;
};

What does const after a member function mean in C++?

It means the function promises not to modify the object it is called on, except for mutable members.

Can a const member function be called on a non-const object?

Yes. A const member function can be called on both const and non-const objects.

Why do I get an error calling a method on a const object?

Because the method is not marked const. The compiler only allows const member functions to be called on const objects.

Is const char* foo() const the same const twice?

No. const char* makes the returned characters read-only through the pointer. The trailing const means the function does not modify the object.

Can a const member function change anything at all?

Yes, it can modify members marked mutable. It can also change external objects through pointers or references if your code allows it, but it should not change the logical state of the object itself.

Should every getter be const?

Usually yes. If a getter only reads data, it should normally be marked const.

What is const correctness in C++?

Const correctness

A broader design practice that includes const variables, const references, and const member functions.

this pointer

Trailing const changes the type of this inside a member function.

mutable

Allows specific members to be modified even inside a const member function.

Const references

Often used with const member functions so objects can be passed efficiently without allowing modification.

Member function overloading

C++ allows const and non-const versions of the same member function.

Getters and setters

A common design area where const member functions are used correctly.

Operator overloading

Conversion operators and comparison operators are often marked const because they usually should not modify the object.