Question

I just wanted to know What are the factors decisive in making a function call during
overloading. As I know its the signature of parameters, number of parameters passed
Which plays an important role. But is there the const part also Which plays an important
part in overloading or not. Overloading of 1st and 2nd function works fine but if a add
a third function with const as a characteristic in passed parameters, I get compilation error. int A::sum(int, int) and int A::sum(int, int) cannot be overloaded. Just giving the code snippet for class:

class A
{
    private:
    int x;
    int y;

    public:
    int sum ( int a, int b )
    {
        cout << " Inside 1st ";
        return (a+b) ;
    }

    int sum (int a ,int b) const
    {
        cout << " Inside 2nd ";
        return (a+b) ;
    }

    int sum (const int a ,const int b)
    {
        cout << " Inside 3rd ";
        return (a+b) ;
    }

    A(){x=0;y=0;}
    ~A(){};
}; 

When I declare the normal object and make a call to sum the first function gets called and in case of a const object second sum is being called. That’s perfectly fine. But if I write 1st and 3rd function both it becomes an issue. Why so?

Answer 1

You can overload on const-ness, but only where it actually makes a difference. What do I mean “actually makes a difference”? Well, if you declare

void foo(char *ptr);
void foo(const char *ptr);

the const matters: you are saying that one overload of foo guarantees not to modify the memory that ptr points to, and the other doesn’t. But if you declare

void foo(int x);
void foo(const int x);

the const doesn’t matter: scalar arguments are always passed by value, so neither hypothetical variation of foo can modify the value of x in its caller, even if it wanted to. Therefore, the C++ standard says that the const is discarded, and these are two different declarations of the same function, one of which is erroneous.

The position of the const relative to the * matters. A pointer is itself a scalar, so these are also two declarations of the same function:

void foo(char *ptr);
void foo(char *const ptr);

because here the const qualifies the pointer itself rather than the object it points to.

That brings us to methods: a const qualifier after the argument list on a method declaration applies to the object pointed to by this, and that can be overloaded on:

struct A
{
  int foo (char *ptr);
  int foo (char *ptr) const;
  int foo (const char *ptr);
  int foo (const char *ptr) const;
};

You should think of these declarations as being rewritten internally to:

struct A {};
int A_foo (A *this, char *ptr);
int A_foo (const A *this, char *ptr);
int A_foo (A *this, const char *ptr);
int A_foo (const A *this, const char *ptr);

and then everything works according to the normal rules for overloaded functions.