The "const" at the end of a C member function means the function promises not to modify the object’s state. It allows the function to be called on const objects, ensures read-only access to member variables, and improves code safety and clarity. Key points: 1) The this pointer becomes a const pointer. 2) Non-mutable members cannot be modified. 3) Const functions can be called on const instances. 4) Mutable members can still be changed. 5) Overloading based on constness is possible. Proper declaration requires the const keyword in both the class declaration and function definition.

A const member function in C is a function that guarantees it won’t modify any of the object’s data members. When you declare a member function as const, you're telling both the compiler and other developers that this function can be called on a const object, and it won't change the state of that object.

This is especially useful when working with const objects or passing objects by const reference — you want to ensure that certain methods can still be safely called without altering the object.

What does "const" at the end of a function mean?

Putting const after a member function's parameter list means that the function promises not to change the internal state of the object:

class MyClass {
public:
    int getValue() const;
private:
    int value_;
};

In this example, getValue() is a const member function. It can be called even on a const instance of MyClass.

Key points:

• The this pointer inside a const function becomes a pointer to a const object.
• You cannot modify non-mutable member variables inside a const function.
• If a function doesn’t need to change the object, it should be made const — it increases usability and clarity.

Why use const member functions?

Const correctness improves code safety and readability. Here’s why it matters:

• Allows calling functions on const objects: Without const functions, you couldn’t call even read-only operations on const instances.
• Enforces immutability: It helps prevent accidental changes to object state.
• Improves optimization opportunities: Compilers can make better assumptions about const functions.
• Better interface design: Signals intent clearly to users of your class.

For example:

MyClass obj;
const MyClass c_obj;

obj.getValue();   // OK
c_obj.getValue(); // Also OK *only* if getValue() is const

If getValue() wasn’t marked const, the second line would result in a compilation error.

What can and can’t you do inside a const function?

Inside a const member function:

• ? Access member variables (but not change them)
• ? Call other const member functions
• ? Return copies or const references to internal data

But you can’t:

• ? Modify regular member variables
• ? Call non-const member functions
• ? Change the state of the object (unless using mutable)

One exception: if a member variable is declared mutable, it can still be modified inside a const function. This is useful for things like caching or internal counters that don’t affect the logical constness of an object.

Example:

class Logger {
public:
    void log(const std::string& message) const {
          call_count_;  // allowed because call_count_ is mutable
        std::cout << message << std::endl;
    }
private:
    mutable int call_count_ = 0;
};

How to declare and define const functions properly

When defining a const function outside the class declaration, you must include the const keyword in both the declaration and the definition:

Header (declaration):

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

Implementation (definition):

int MyClass::getValue() const {
    return value_;
}

If you forget const in the definition, the compiler will treat it as a different function — leading to errors.

Also, remember:

• Overloading based on constness is possible. For example, you can have both T& operator[] (size_t) and T operator[] (size_t) const.
• Const and non-const versions can behave differently, but should ideally provide consistent results.

Const member functions are a core part of writing robust and maintainable C . They help enforce good practices around object state and improve how your classes interact with const contexts. Once you get used to marking functions as const where appropriate, it becomes a natural part of clean C coding habits.

That’s basically it — nothing too fancy, but something easy to overlook when first learning C .

The above is the detailed content of What is a const member function in C ?. For more information, please follow other related articles on the PHP Chinese website!