Question

Considering the following piece of code.

#include <iostream>
using namespace std;

class Object
{
public:
    Object() {}

    void Print() const
    {
        cout << "const" << endl;
    }

    void Print()
    {
        cout << "mutable" << endl;
    }
};

void print_obj(const Object& obj)
{
    obj.Print();
}

int main()
{
    Object       obj1;
    const Object obj2;
    Object*const pobj1 = &obj1;
    
    print_obj(obj1);
    print_obj(obj2);
    
    obj1.Print();
    obj2.Print();
    
    pobj1->Print();
    
    return 0;
}

The output is

const
const
mutable
const
mutable

I am wondering, how does C++ decide which method to invoke, when facing many mutable methods with the same name?

Answer 1

print_obj(obj1); 
print_obj(obj2); 

The function to be called is evaluated on the basis of the cv-qualifier(const/volatile) of the passed object. Note that cv-qualifiers are considered while function overload resolution.
If passed object is const, function receiving const argument is selected.If passed object is non-const then function receiving non-const argument is selected.

---

obj1.Print();   
obj2.Print();   
pobj1->Print();

If the object is const then only call const member function can be called.
If the object is non-const then the non-const version is prefferred over the const version.

The rules are clearly specified by the standard.

Reference:
C++03 standard:
§13.3.1 Candidate functions and argument lists:

For non-static member functions, the type of the implicit object parameter is “reference to cv X” where X is the class of which the function is a member and cv is the cv-qualification on the member function declaration. [Example: for a const member function of class X, the extra parameter is assumed to have type “reference to const X”. ]

So if the object is const compiler will pick version of member function which has implicit object parameter of type reference to const Object which is const version of Print().