Die Werte von geerbten Objekte werden aber nicht mitkopiert.

Ich versuchte mit

virtual Object & operator=(const Object & ref)

die geerbten Klasse wird so deklariert: class ObWave : public Object
Nun darf ich die Deklarationen von Kopiermethode Object nicht in ObWave ändern.

Object & operator=(const Object & ref)

Wie hol ich hier die geerbten Werte aus ref? Muss ich hier upcast nehmen? Wenn ja, wie innerhalb Kopiermethode?

das geht wohl nicht wegen const?

this->steps = static_cast<ObWave*>(&ref)->getSteps();

einfach const wegmachen? ich frage mich eigentlich wie man damit sonst umgeht?

this->steps = dynamic_cast<ObWave const*>(&ref)->getSteps();

Object & operator=(const Object & ref)

Wie hol ich hier die geerbten Werte aus ref? Muss ich hier upcast nehmen? Wenn ja, wie innerhalb Kopiermethode?

Was genau treibst du denn da? Die Tatsache dass du dir überhaupt diese Frage stellst lässt sehr stark vermuten dass es nichts Gutes ist...

Wenn du mit Zeigern (bzw. hoffentlich Smart-Pointern) arbeitest, ist die übliche Methode, den Klassen eine virtuelle clone-Methode der Form

virtual classname *clone() const { return new classname(*this); }

zu geben. Auf die Art lässt sich

std::auto_ptr<A> ptr_d = new B;
std::auto_ptr<A> ptr_s = new C;

// ...

ptr_d = ptr_s->clone();

// ptr_d zeigt jetzt auf ein Objekt vom Typ C

schreiben.

Object & operator=( const Object & ref) {
		Object::operator=(ref);
		this->steps = dynamic_cast<ObWave const*>(&ref)->getSteps();
		this->wavelenght = dynamic_cast<ObWave const*>(&ref)->getWavelenght();
        return *this;
    }

dass mit C und B nicht geht habe ich noch nicht probiert
Leider hab ich noch nie mit smart-pointern gearbeitet.

hoffentlich ist std::auto_ptr plattformunabhängig?

Zu deinem Code: Du solltest eventuell abfangen, ob der Cast wirklich funktioniert hat:

Object & operator=( const Object & ref) {
  Object::operator=(ref);
  const ObWave* src = dynamic_cast<const ObWave*>(&ref)
  if(src)
  {
    this->steps = src->getSteps();
    this->wavelenght = src->getWavelenght();
    return *this;
  }
  else
  {
    //Fehlerbehandlung - das übergebene Objekt war kein ObWave
  }
}

struct ObPointer {
	Object *objp;
};

Object *obj_copy;

	obj_copy = QVariant(parent_item->data(ObjectRole)).value<ObPointer>().objp; // Qt Zeile (anderes Thema)

	ObPointer obp;

	if (obj_copy->type() == 1)
		obp.objp = new ObWave();
	else if (obj_copy->type() == 2)
		obp.objp = new ObSpiral();
	else
		obp.objp = new Object();

	*obp.objp = *obj_copy;

glaub mit clone wäre besser. aber dann müsste ich eher shared pointer nehmen, weil bestimmt mehrere Zeiger auf ein object gezeigt werden

Zu deinem Code: Du solltest eventuell abfangen, ob der Cast wirklich funktioniert hat:
(...)

Ja, sollte er. Geht aber auch einfacher:

Object & operator=( const Object & ref) {
  Object::operator=(ref);
  const ObWave& src = dynamic_cast<const ObWave&>(ref);
  this->steps = src.getSteps();
  this->wavelenght = src.getWavelenght();
  return *this;
}

Ja, sollte er. Geht aber auch einfacher:

Stimmt, aber ganz so extrem wollte ich die Aufgabe auch nicht lösen