Home » C++ » Overloading by return type

Overloading by return type

Posted by: admin November 30, 2017 Leave a comment

Questions:

I read few questions here on SO about this topic which seems yet confusing to me. I’ve just begun to learn C++ and I haven’t studied templates yet or operator overloading and such.

Now is there a simple way to overload

class My {
public:
    int get(int);
    char get(int);
}

without templates or strange behavior? or should I just

class My {
public:
    int get_int(int);
    char get_char(int);
}

?

Answers:

No there isn’t. You can’t overload methods based on return type.

Overload resolution takes into account the function signature. A function signature is made up of:

  • function name
  • cv-qualifiers
  • parameter types

And here’s the quote:

1.3.11 signature

the information about a function that participates in overload
resolution (13.3): its parameter-type-list (8.3.5) and, if the
function is a class member, the cv-qualifiers (if any) on the function
itself and the class in which the member function is declared. […]

Options:

1) change the method name:

class My {
public:
    int getInt(int);
    char getChar(int);
};

2) out parameter:

class My {
public:
    void get(int, int&);
    void get(int, char&);
}

3) templates… overkill in this case.

Questions:
Answers:

It’s possible, but I’m not sure that it’s a technique I’d recommend for
beginners. As in other cases, when you want the choice of functions to
depend on how the return value is used, you use a proxy; first define
functions like getChar and getInt, then a generic get() which
returns a Proxy like this:

class Proxy
{
    My const* myOwner;
public:
    Proxy( My const* owner ) : myOwner( owner ) {}
    operator int() const
    {
        return myOwner->getInt();
    }
    operator char() const
    {
        return myOwner->getChar();
    }
};

Extend it to as many types as you need.

Questions:
Answers:

No, you can’t overload by return type; only by parameter types, and const/volatile qualifiers.

One alternative would be to “return” using a reference argument:

void get(int, int&);
void get(int, char&);

although I would probably either use a template, or differently-named functions like your second example.

Questions:
Answers:

You can think this way:

You have:

  int get(int);
  char get(int);

And, it is not mandatory to collect the return value of the function while invoking.

Now, You invoke

  get(10);  -> there is an ambiguity here which function to invoke. 

So, No meaning if overloading is allowed based on the return type.

Questions:
Answers:

There is no way to overload by return type in C++. Without using templates, using get_int and get_char will be the best you can do.

Questions:
Answers:

You can’t overload methods based on return types. Your best bet is to create two functions with slightly different syntax, such as in your second code snippet.

Questions:
Answers:

you can’t overload a function based on the return type of the function.
you can overlead based on the type and number of arguments that this function takes.

Questions:
Answers:

While most of the other comments on this problem are technically correct, you can effectively overload the return value if you combine it with overloading input parameter. For example:

class My {
public:
    int  get(int);
    char get(unsigned int);
};

DEMO:

#include <stdio.h>

class My {
public:
    int  get(         int x) { return 'I';  };
    char get(unsinged int x) { return 'C';  };
};

int main() {

    int i;
    My test;

    printf( "%c\n", test.get(               i) );
    printf( "%c\n", test.get((unsigned int) i) );
}

The resulting out of this is:

I 
C