Overloading by return type

问题:

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);
}

?

回答1:

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.

回答2:

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.

回答3:

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.

回答4:

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.

回答5:

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.

回答6:

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.

回答7:

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

回答8:

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.