Question

I’m trying to understand the concept of operator overloading by writing some simple, silly tests. I thought this might be useful as this helps me understand C++ better.

Why does this example implementing a concatenation operator of Animal class and std::string not compile? G++ gives me the following error:

extra qualification ‘Animal::’ on member ‘operator+’ [-fpermissive]

This is the code:

#include <iostream>
using namespace std;

class Animal {

public:
    string _type;
    string _name;
    string _sound;


    Animal & Animal::operator+(const string & o);
};


Animal & Animal::operator+(const string & o) {
    cout << "plus operator \n";
    this->_name=o;
    return *this;
}


int main( int argc, char ** argv ) {
    Animal a;

    a+"hhh";
    cout<<a._name;
    return 0;
}

Answer 1

Animal & Animal::operator+(const string & o);

Is invalid. It should be:

Animal & operator+(const string & o);

Also, your implementation of a simple addition operator, results in the modifications of one of the operands. This is never a good thing for an addition operator.

For example:

int a, b = 5, c = 3;
a = b + c;

That doesn’t change the values of either operands; it leaves b and c untouched, and returns an entirely different instance.

You should therefore not overload the addition operator, but the addition assignment compound operator (+=):

Animal & operator+=(const string & o);

And of course change the implementation and calls to it accordingly:

Animal & Animal::operator+=(const string & o) {
    cout << "plus operator \n";
    this->_name=o;
    return *this;
}

And:

a += "hhh";