C++ overloading operator =

Question

0.00/5 (No votes)

See more:

Hi everybody,

I have a question for you about overloading operator = for derived classes.
Suppose for example to have two classes A, B defined like this:

class A
{
protected:
	double v_;

public:

	A(double initVal = 0.0)
	: v_(initVal)
	{}

	virtual ~A() {}
	
	double v() 
        {
	   return v_;
	}

	void v(double val) { v_ = val; }


	A& operator=(A& src)
	{
	   this->v(src.v());
	}

};


//defining sum 
A operator+(A& add1, A& add2)
{
	A res;
	res.v(add1.v() + add2.v());
	return res;
}


class B : public A
{
public:

	B(double initVal = 0.0)
		: A(initVal)
	{}

	virtual ~B() {}

	B(B& src)
		: A(src.v())
	{}
	
	B(A& src)
		: A(src.v())
	{}


	B& operator=(B& src)
	{
		B res;
		res.v(src.v());
		return res;
	}

	B& operator=(A& src)
	{	
		B res;
		res.v(src.v());
		return res;
	}
};

now if i debug the following lines:

A a(1.0);
B b(2.0);	
B c;
//first Assignemnt
c = a;
//second assignment
c = a + b;

i can see that the both the assignment pass through

B& B::operator=(A& src)

Now if i modify

B& operator=(B& src)

to

B& operator=(B src)

the second assignment (with the sum) passes through this operator.

Somebody can please explain why this happens?

thank you

What I have tried:

Is the reason of this behaviour the implicit cast?

Posted 5-Dec-17 0:31am

Optimistic76

Updated 5-Dec-17 3:58am

Add a Solution

4 solutions

Solution 2

I have not checked your code and what it does because it is not implementing the assignment operators in the usual way. They should not return a copy but the object itself (note also that the operator in your class A is returning nothing).

It should be:

class A
{
    // ...
    double v() const
    {
        return v_;
    }
    
    A& operator=(const A& src)
    {
        this->v(src.v());
        return *this;
    }

    // This is missing in your code and should be there
    friend A operator+(const A& add1, const A& add2);
};

A operator+(const A& add1, const A& add2)
{
    // EDIT: Or just (because we are friend, we have direct access to the members)
    return A(add1.v_ + add2.v_);
    //A res;
    //res.v(add1.v() + add2.v());
    //return res;
}

class B
{
    // ...
    B& operator=(const B& src)
    {
        this->v(src.v());
        return *this;
    }
     
    B& operator=(const A& src)
    {	
        this->v(src.v());
        return *this;
    }
};

Note also that the parameters should be const and so should be the getter function v().

Posted 5-Dec-17 1:18am

Jochen Arndt

Updated 5-Dec-17 1:27am

v3

Solution 3

I suggest you to have a look at this page: Copy constructors, assignment operators, - C++ Articles[^].

Posted 5-Dec-17 1:34am

CPallini

Solution 4

if you are interested maybe i have found what i was searching for

C++ Explained: Object initialization and assignment, lvalues and rvalues, copy and move semantics and the copy-and-swap idiom | Katy's Code[^]

Posted 5-Dec-17 3:58am

Optimistic76

Add a Solution

Add your solution here

Treat my content as plain text, not as HTML

Preview 0

…

Existing Members

Sign in to your account

...or Join us

Download, Vote, Comment, Publish.

Your Email
Password
Forgot your password?

Your Email
This email is in use. Do you need your password?
Optional Password

I have read and agree to the Terms of Service and Privacy Policy
Please subscribe me to the CodeProject newsletters

When answering a question please:

Read the question carefully.
Understand that English isn't everyone's first language so be lenient of bad spelling and grammar.
If a question is poorly phrased then either ask for clarification, ignore it, or edit the question and fix the problem. Insults are not welcome.
Don't tell someone to read the manual. Chances are they have and don't get it. Provide an answer or move on to the next question.

Let's work to help developers, not make them feel stupid.

This content, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

tra_la_la_la · Accepted Answer · 2017-12-05T01:07:00

Solution 1

Make the constructor

B(A& src)

explicit.
Smth like

explicit B(A& src)

Posted 5-Dec-17 1:07am

tra_la_la_la

Comments

Optimistic76 5-Dec-17 8:10am

Hi tra_la_la_la,

ok if i make explicit the constructor both the assignment pass through B::operator=(A&) but i would like to know what is the logic behind this.
Why the A a is considered is some way differente from the object that the addition operator returns?