Thread: unable to overload functions

hey guys! I started fiddling with C++ to expend my programming knowledge , I wrote a program (which has no use other then practicing subjects I learned )

the compiler complains that the call of overloaded "addEm" is ambiguous. I read that this probably means it can't tell which version of the function is used, yet, I don't understand how to fix it ..

Code:

#include <iostream>

using namespace std;

class cat {
    private:
        int age;
        int height;
    public:
        cat();
        cat(int a, int b);
        ~cat();
        void setAge(int a);
        void setHeight (int a);
        int getAge(void) const;
        int getHeight(void) const;
        void showDetails (void);    
};

int addEm (cat myCat);
int addEm (const cat& myCat);    


    cat::cat(){
            cout<<"\ndefault constructor called\n";
            age=0;
            height=0;
    }
        
    cat::cat(int a, int b){
            cout<<"\nregular constructor\n";
            age=a;
            height=b;
    }
    
    cat::~cat(){
            cout<<"\ndeleting this cat\n";
    }
        
    void cat::setAge(int a) {
            age=a;
    }
        
    void cat::setHeight (int a) {
            height=a;
    }
        
    void cat::showDetails (void){
            cout<<"this cat is "<<age<<" years old and it's height is "<<height; 
    }
        
    int cat::getAge(void) const{
            return age;
    }
    
        int cat::getHeight(void) const{
            return height;
    }


int addEm (cat myCat){
    int a,b;
    a=myCat.getHeight();
    b=myCat.getAge();
    return a+b;
}

int addEm (const cat& myCat){
    int a,b;
    a=myCat.getHeight();
    b=myCat.getAge();
    return a+b;
}

int main (void){
    
    cat blacky(3,4);
    const cat& rBlacky=blacky;
    cout<<addEm(rBlacky);
    
    cout <<"\n end the program:\n";
    return 0;
}

Code:

intaddEm (cat myCat);
int addEm (const cat& myCat);

An ambigous call is what you think it is, and this happens because your two functions may take the same argument. Needless to say, it cant know which one is correct.
To fix this you could just change the name of one of the functions. But considering they are identical, what you could rather do is just remove one of them. >.>

^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Purrfect explanation

（ΦωΦ）

Originally Posted by Dave11

so basically the problem is that the compiler does not differentiate between <type> and cons <type> as far as it comes to declaring arguments of a function?

No, it does. Remove the call to the function and you'll see that it compiles. Essentially, the compiler cannot differentiate between the functions when you call it. It doesn't know which one to call.

Originally Posted by Dave11

1) is there any OTHER difference between the obvious fact that the first return a type and the other return a reference? in terms of functionallity, etc?

I'm going to chance and guess no. I cannot know what it is you are after, but really, the only thing different is that that returned expression will be a reference, so the returned expression must be alive after the function ends.

Originally Posted by Dave11

2) is there any reason to return reference of a variable and not the variable itself?

Yes, it happens regularly with operator overloading when a class returns a reference to itself to enable chaining (i.e. a = b = c = d...).

The compiler knows it's a reference by looking at its type, but the you can also create a temporary from your reference.
The compiler cannot decide between creating a temporary and passing a reference.

void foo(T); // <--- Can call this by making a copy of the variable
void foo(const T&); // <-- Can call this directly.

But both are equally "good" in the compiler's eyes, so it cannot decide which one to call.
The thing about references are that they behave just exactly like normal variables.

Well, to be fair...

Code:

void foo (const K& x);
void foo (K k);
 
int main()
{
  K k;
  copy K& rK = k;
  foo(rK);
}

...using this example, the type is actually const K&, so the const K& foo would be a stronger "match". However, when the compiler looks at foo(K), it also sees that it can call K's copy constructor to make a copy and hence call foo(K). This is considered an equally "strong" match, so the compiler is cannot deduce which one to call. There are tons of "rules" for overloading which tells the compiler which overload to pick and they're quite complicated in order to make it "seem" like the compiler picks the right choice every time.

Also, to show something off:

Code:

struct X 
{
	X() {}
	explicit X(const X&) {}
};

void foo(X) { std::cout << "foo(X)\n"; }
void foo(const X&) { std::cout << "foo(const X&)\n"; }

int main()
{
	X MyX;
	foo(MyX);
}

Does it compile? Does it run? If so, what does it print? The correct answer is foo(const X&). Why? Because I told the compiler: make no implicit copies of this object. Hence, the compiler discarded foo(X) and called foo(const X&). So you can clearly see here why the compiler complains it's ambiguous (remove the explicit keyword).