overloading derived class

[l2u]

Hello

I want to overload copy assignment operator of base class in derive class. For instance:
Class base and derive have some copy assignment operator.

Heres the class definition:

class derive : public base {
public:
  base() { }
  base(int n) : num(n) { }
  base& operator= (const base& source) {
     if (this == &source) return *this; //self-assignment check
     num = source.num;
     return *this;
  }
private:
  int num;
};

This will only copy num to new instance if I do:

derive instance;
derive instance2 = instance;

What should I do so that copy assignment operator from derived class will be used?

[CornedBee]

OK, I'm extremely confused by your post. Why does base derive from derived, instead of the other way round, as the names suggest?

[l2u]

OK, I'm extremely confused by your post. Why does base derive from derived, instead of the other way round, as the names suggest?

Sorry, I mixed it up.

[CornedBee]

Still messed up. Now the derived class tries to define constructors using base as the name. The assignment operator uses base as the argument and return type. And the usage example might also not be what you intended.

[cpjust]

This will only copy num to new instance if I do:

base base_instance;
base instance2 = base_instance;

What should I do so that copy assignment operator from derived class will be used?

How can the code above call anything from a derived class if you're only creating base class objects?

[l2u]

I fixed the mistake now, hope its correct now
Thanks for help

[matsp]

class derive : public base {
public:
  derive() { }
  derive(int n) : num(n) { }
  derive& operator= (const derive& source) {
     if (this == &source) return *this; //self-assignment check
     num = source.num;
     return *this;
  }
private:
  int num;
};

I fixed up the "mixed".

In this class, you don't actually need an assignment operator, the default one will do exactly the same job.

--
Mats

[anon]

The self-assignment check is quite unnecessary here, too. Whatever you gain from not assigning a variable to itself in a few cases comes at the price of an additional check every single time.

Avoiding self-assignment is critical if you for example freed the currently held memory first, only to discover that you have just deleted the pointer whose contents you wanted to copy.

But then, this design is problematic too: it is better not to free old resources before you have successfully acquired new ones.

[Elysia]

I don't know if you can override a base operator? I think I'm going to try.
Well, looks like you can IF the base operator is NOT defined or is pure virtual.

[l2u]

class derive : public base {
public:
  derive() { }
  derive(int n) : num(n) { }
  derive& operator= (const derive& source) {
     if (this == &source) return *this; //self-assignment check
     num = source.num;
     return *this;
  }
private:
  int num;
};

I fixed up the "mixed".

In this class, you don't actually need an assignment operator, the default one will do exactly the same job.

--
Mats

I want the default assignment operator (in base class) to do the job and beside that the assignment operator in derive class should also copy num to the other instance.

[Elysia]

To do such a thing you need to overload a new assignment operator for Derived. It will be called when you assign Derived objects. In case you want to base class to handle all the functionality, you can call the Base class's assignment operator (Base:perator = (source)).
But really, there's no need since all members are copied to the new object by default (shallow copy) when you do assignment, so in this case you don't need to overload operator =.

[l2u]

I tried doing:

class derive : public base {
public:
  derive() { }
  derive(int n) : num(n) { }
  derive& operator= (const derive& source) {
     base::operator=(source);
     num = source.num;
     return *this;
  }
private:
  int num;
};

But it seems like it only copies 'num' to new instance, not the objects in base class.

[Elysia]

...not the objects in base class...

What does that mean?

[l2u]

What does that mean?

It seems like it doesnt call the copy assignment operator in base class.

[CornedBee]

Can we have a complete test case, please? Something like this:

#include <iostream>

class base
{
public:
	int i1;

	base(int a1) : i1(a1) {}
	base(const base &o) : i1(o.i1) {}
	base &operator =(const base &o) { i1 = o.i1; return *this; }
};

class derived : public base
{
public:
	int i2;

	derived(int a1, int a2) : base(a1), i2(a2) {}
	derived(const derived &o) : base(o), i2(o.i2) {}
	derived &operator =(const derived &o) {
		base::operator=(o);
		i2 = o.i2;
		return *this;
	}
};

int main()
{
	derived d1(10, 15);
	derived d2(20, 25);
	d1 = d2;

	std::cout << "d1: " << d1.i1 << ", " << d1.i2 << "\n";
}

This does exactly what is expected. How does your code differ?