operator=

[Corey Cooper]

I have a class for which I needed to create an operator= function. I then
use that as a base class for another class, which also needs an operator=.
What is the syntax to use in the derived class operator= function to copy
the base classes variables in the derived class (without just copying the
code?)

A much simplified example:

class Base
{
public:
Base();
~Base();

Base &operator=(cons t Base &B);

protected:
int i;
}

Base &Base::operator =(const Base &B)
{
if (this == &B)
return *this;
i = B.i;
return *this;
};
class Derived : public Base
{
Derived();
~Derived();

Derived &operator=(cons t Derived &D);

protected:
int n;
};

Derived &Derived::opera tor=(const Derived &B)
{
if (this == &B)
return *this;

// None of these work!
//(Base)(*this) = ::operator=B;
//(*this) =(const Base &)B;

n = B.n;
return *this;
};

And yet, in code not directly in these classes, this works fine:
Base b;
Derived d;
d = b;

Thanks!
Corey

[cipher]

Hi,

make method "operator=" virtual, this should help. Non-virtual methods
cannot be overwritten, so you will always use operator= from class
Base.

Greetings from Bavaria,
Markus

[sheffmail]

On Jun 5, 10:09 am, "Corey Cooper" <Co...@EntecSys tems.netwrote:

I have a class for which I needed to create an operator= function. I then
use that as a base class for another class, which also needs an operator=.
What is the syntax to use in the derived class operator= function to copy
the base classes variables in the derived class (without just copying the
code?)

A much simplified example:

class Base
{
public:
Base();
~Base();

Base &operator=(cons t Base &B);

protected:
int i;

}

Base &Base::operator =(const Base &B)
{
if (this == &B)
return *this;
i = B.i;
return *this;

};

class Derived : public Base
{
Derived();
~Derived();

Derived &operator=(cons t Derived &D);

protected:
int n;

};

Derived &Derived::opera tor=(const Derived &B)
{
if (this == &B)
return *this;

// None of these work!
//(Base)(*this) = ::operator=B;
//(*this) =(const Base &)B;

n = B.n;
return *this;

};

And yet, in code not directly in these classes, this works fine:
Base b;
Derived d;
d = b;

Thanks!
Corey

Derived &Derived::opera tor=(const Derived &B)
{
if (this == &B)
return *this;

// None of these work!
//(Base)(*this) = ::operator=B;
//(*this) =(const Base &)B;

n = B.n;
Base::operator =(B);

return *this;
};

[jason.cipriani]

On Jun 5, 2:09 am, "Corey Cooper" <Co...@EntecSys tems.netwrote:

I have a class for which I needed to create an operator= function. I then
use that as a base class for another class, which also needs an operator=.
What is the syntax to use in the derived class operator= function to copy
the base classes variables in the derived class (without just copying the
code?)

Derived &Derived::opera tor=(const Derived &B)
{
if (this == &B)
return *this;

You want:

Base::operator = (B);

>
n = B.n;
return *this;

};

That's also the general syntax for calling the base implementation of
a function.

class Base {
virtual void f () { }
};

class Derived : public Base {
void f () {
Base::f();
// ...
}
};
Jason

[jason.cipriani]

On Jun 5, 2:32 am, cipher <markus.doersch [e-mail] rote:

make method "operator=" virtual, this should help. Non-virtual methods
cannot be overwritten, so you will always use operator= from class
Base.

That will not help the main problem, though. Also, the derived
operator = takes a Derived&, not a Base&. Virtual or not, if you are
calling operator = on a Base, it will always use the Base one, e.g.:

void assign (Base &a, const Base &b) {
a = b;
}

Will always call Base::operator= only, no matter what derived classes
you pass it. Making operator = virtual in the Base will case
Derived::operat or= to be called only if there is a
Derived::operat or=(Base&), e.g.:
class Base {
public:
virtual Base & operator = (const Base &); // (1)
};

class Derived {
public:
Derived & operator = (const Derived &); // (2)
Derived & operator = (const Base &); // (3)
};

void assign (Base &a, const Base &b) {
a = b;
}

void f () {
Derived a, b;
a = b; // This calls (2).
assign(a, b); // This calls (3).
}
And assign(a, b) would call (1) if (1) wasn't virtual. But it will
never call (2).
Jason

[Corey Cooper]

You want:

>
Base::operator = (B);

>>
n = B.n;
return *this;

};

That's also the general syntax for calling the base implementation of
a function.

Ahh! I forgot that operator= is like any other function, and I kept wanting
to put something on the left of the equals sign!

Thanks All!
<ja************ @gmail.comwrote in message
news:f3******** *************** ***********@i76 g2000hsf.google groups.com...

On Jun 5, 2:09 am, "Corey Cooper" <Co...@EntecSys tems.netwrote:

>I have a class for which I needed to create an operator= function. I
then
use that as a base class for another class, which also needs an
operator=.
What is the syntax to use in the derived class operator= function to copy
the base classes variables in the derived class (without just copying the
code?)

> Derived &Derived::opera tor=(const Derived &B)
{
if (this == &B)
return *this;

You want:

Base::operator = (B);

>>
n = B.n;
return *this;

};

That's also the general syntax for calling the base implementation of
a function.

class Base {
virtual void f () { }
};

class Derived : public Base {
void f () {
Base::f();
// ...
}
};
Jason

[James Kanze]

On Jun 5, 8:09 am, "Corey Cooper" <Co...@EntecSys tems.netwrote:

I have a class for which I needed to create an operator=
function. I then use that as a base class for another class,
which also needs an operator=. What is the syntax to use in
the derived class operator= function to copy the base classes
variables in the derived class (without just copying the
code?)

A much simplified example:

class Base
{
public:
Base();
~Base();

Base &operator=(cons t Base &B);

protected:
int i;
}

Base &Base::operator =(const Base &B)
{
if (this == &B)

What's this check for? It just wastes time, and is usually a
sign of other problems (but here, it's just unnecessary).

return *this;
i = B.i;
return *this;
};

class Derived : public Base
{
Derived();
~Derived();

Derived &operator=(cons t Derived &D);
protected:
int n;
};

Derived &Derived::opera tor=(const Derived &B)
{
if (this == &B)

(As above.)

return *this;

// None of these work!
//(Base)(*this) = ::operator=B;
//(*this) =(const Base &)B;

What's wrong with just:

Base::operator= ( B ) ;

n = B.n;
return *this;
};

And yet, in code not directly in these classes, this works fine:
Base b;
Derived d;
d = b;

It does? It shouldn't compile.

--
James Kanze (GABI Software) email:ja******* **@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientier ter Datenverarbeitu ng
9 place Sémard, 78210 St.-Cyr-l'École, France, [phone]

[James Kanze]

On Jun 5, 8:32 am, cipher <markus.doersch [e-mail] rote:

make method "operator=" virtual,

Never make the operator= function virtual. It can't be made to
work correctly.

--
James Kanze (GABI Software) email:ja******* **@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientier ter Datenverarbeitu ng
9 place Sémard, 78210 St.-Cyr-l'École, France, [phone]

[Corey Cooper]

"James Kanze" <ja*********@gm ail.comwrote in message
news:d4******** *************** ***********@56g 2000hsm.googleg roups.com...
On Jun 5, 8:09 am, "Corey Cooper" <Co...@EntecSys tems.netwrote:

I have a class for which I needed to create an operator=
function. I then use that as a base class for another class,
which also needs an operator=. What is the syntax to use in
the derived class operator= function to copy the base classes
variables in the derived class (without just copying the
code?)

A much simplified example:

class Base
{
public:
Base();
~Base();

Base &operator=(cons t Base &B);

protected:
int i;
}

Base &Base::operator =(const Base &B)
{
if (this == &B)

What's this check for? It just wastes time, and is usually a
sign of other problems (but here, it's just unnecessary).

return *this;
i = B.i;
return *this;
};

class Derived : public Base
{
Derived();
~Derived();

Derived &operator=(cons t Derived &D);
protected:
int n;
};

Derived &Derived::opera tor=(const Derived &B)
{
if (this == &B)

(As above.)

return *this;

// None of these work!
//(Base)(*this) = ::operator=B;
//(*this) =(const Base &)B;

What's wrong with just:

Base::operator= ( B ) ;

n = B.n;
return *this;
};

>And yet, in code not directly in these classes, this works fine:
Base b;
Derived d;
d = b;

>It does? It shouldn't compile.

VC++ 6.0 it works.
c.

--
James Kanze (GABI Software) email:ja******* **@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientier ter Datenverarbeitu ng
9 place Sémard, 78210 St.-Cyr-l'École, France, [phone]

[Daniel T.]

"Corey Cooper" <Co***@EntecSys tems.netwrote:

I have a class for which I needed to create an operator= function. I then
use that as a base class for another class, which also needs an operator=.

That sounds like a very bad idea.

void fn(Base& b, Derived& d)
{
b = d;
d = b;
}

AFAIK, in both of the above, Base::op=(const Base&) will be called, but
what if 'b' is a reference to a Derived object?

I don't think the base class should have an op= function. I think the
right thing to do is to make the Base::op= private and not implemented.