Floor& Floor::operator =(Floor const & c)
{
	if(this!=&c)
		Floor(c);
	return *this;
}

allerdings bekomme ich folgende fehlermeldung:

error C2679: binary '=' : no operator found which takes a right-hand operand of type 'Floor *const ' (or there is no acceptable conversion)

die klassenkonstruktion ist fast die gleiche wie hier:http://www.c-plusplus.net
nur jetzt mit paar kleinen änderungen
[code="cpp"]typedef std::list<Floor*> TFloorList;

in der klasse Haus:

void AddFloor(Floor * const flobj);

implementiere ich die überladung falsch? woran kann das sonst liegen

Habe den = operator bei meiner Klasse überladen

Floor& Floor::operator =(Floor const & c)
{
	if(this!=&c)
		Floor(c); // <-- Das macht ein temporäres Floor-Objekt. Das willst du nicht.
	return *this;
}

allerdings bekomme ich folgende fehlermeldung:
[code] error C2679: binary '=' : no operator found which takes a right-hand operand of type 'Floor *const ' (or there is no acceptable conversion)

Du weist irgendwo einem Floor-Objekt einen Floor-Zeiger zu. Das hat mit der Implementierung des Zuweisungsoperators nichts zu tun.

ACnut schrieb:

Habe den = operator bei meiner Klasse überladen

Floor& Floor::operator =(Floor const & c)
{
	if(this!=&c)
		Floor(c); // <-- Das macht ein temporäres Floor-Objekt. Das willst du nicht.
	return *this;
}

[quote]
allerdings bekomme ich folgende fehlermeldung:

error C2679: binary '=' : no operator found which takes a right-hand operand of type 'Floor *const ' (or there is no acceptable conversion)[/quote]
Du weist irgendwo einem Floor-Objekt einen Floor-Zeiger zu. Das hat mit der Implementierung des Zuweisungsoperators nichts zu tun.[/quote]

was bedeutet temporäres floor-objekt? wird leicht gleich der destruktor aufgerufen oder wie ist das zu verstehen?

ich denke der copy-ctor musste geändert werden
[code="cpp"]
Floor::Floor(const Floor * cFloor)
{
	mNrFlat=(*cFloor).mNrFlat;
}

es ist schon arg bzw. traurig, was man nach drei monaten alles wieder verlernt hat

ACnut schrieb:

was bedeutet temporäres floor-objekt? wird leicht gleich der destruktor aufgerufen oder wie ist das zu verstehen?

Ja. Floor(c) ist ein Ausdruck, der ein Objekt Floor erzeugt. Da du mit dem Ausdruck nichts machst, wird das Objekt sofort danach wieder zerstört.

Du willst eigentlich den Kopierkonstruktor aufrufen. Das geht aber nicht, Konstruktoren werden nur beim Erzeugen neuer Objekte aufgerufen, danach (also z.B. in einer Funktion, die zufällig operator= heißt) nicht mehr.

ich denke der copy-ctor musste geändert werden

Floor::Floor(const Floor * cFloor)
{
	mNrFlat=(*cFloor).mNrFlat;
}

Das wäre kein Copy-Ctor mehr, sondern einfach irgendein Konstruktor, der als Argument einen Zeiger auf const Floor hat.

Habe den = operator bei meiner Klasse überladen

Floor& Floor::operator =(Floor const & c)
{
	if(this!=&c)
		Floor(c);
	return *this;
}

Im op= sollte fast der gleiche Code drinstehen wie im Kopierkonstruktor.

Und dann fällt auf, daß man keinen doppelten Code haben will und implementiert den einen mittels des anderen. Und dann vermutlich am besten per Copy&Swap.

Floor& Floor::operator =(Floor const & c)
{
	Floor tmp(c);
	tmp.swap(*this);//muss auch noch in die Klasse rein. 
	return *this;
}

denn = operator hab ich jetzt so überladen, weil ich das von euch nicht verstanden habe (Floor tmp(c)->was ist tmp?)

Floor& Floor::operator =(Floor const & c)
{
        if (this!=&c)
	(*this).mNrFlat=mNrFlat;
	return *this;
}

//ich hoffe ich kann das einfach mit copy machen?

House::House(const House & cFloor)
{
  std::copy ( cFloor.mFLoors.begin(),cFloor.mFLoors.end(), mFLoors.begin() );
}

void House::AddFloor( Floor const *  flobj)
{
	if(flobj!=0)
		mFLoors.push_back(flobj);
	mNrFloors++;
}

für addfloor kriege ich folgende fehlermeldung:

error C2664: 'void std::list<_Ty>::push_back(_Ty &&)' : cannot convert parameter 1 from 'const Floor *' to 'Floor *&&' Line 73

und

IntelliSense: no instance of overloaded function "std::list<_Ty, _Ax>::push_back [with _Ty=Floor *, _Ax=std::allocator<Floor *>]" matches the argument list	73

ich weiß aber nicht von wo er das FLoor *&& hat und wie ich das lösen soll

kann man eine aggreagtion auch ohne liste ,vector,... von pointern machen? also einfach nur z.b.

vector<klassenname> bla

?

not smart schrieb:

schau halt was dein parameter von AddFloor für n typ hat...

ok jetzt bin ich wieder beim thema zuweisungsoperator. anscheinend stimmt die neue implementierung von dem jetzt nicht

error C2679: binary '=' : no operator found which takes a right-hand operand of type 'const Floor *const ' (or there is no acceptable conversion)

wieso kann ich das nicht einfach so machen?

Floor& Floor::operator =(Floor const & c)
{
        if (this!=&c)
    (*this).mNrFlat=mNrFlat;
    return *this;
}

Warum sollte ein Member wie mNrFlat überhaupt durch einen op= kopiert werden müssen? Hast du überhaupt irgendwelche Pointer-Member in Floor? Wie sehen denn die Header aus?

das weiß ich eben auch noch nicht genau, denn nwie du gesagt hast "rennt" Flat noch ohne Zeiger.

die flats sind noch auskommentiert, weil das die arbeit vom programmierkollegen (soll so eine art pair programming sein, um so eine situation wie in der industrie zu simulieren) ist

ich kann aber euch die "urform"(muss noch geändert werden) der klassenhierarchie zeigen, was wir schon vorher vorbereitet haben:
http://www.imagenetz.de/f0c4d4693/1376701_10201151229995377_1636614969_n.jpg.html

//forward declaration
//class Flat;

//typedefs for list of flats and iterator for flat list
//typedef std::list<Flat*> TFlatList;
//typedef TFlatList::const_iterator TFlatListItor;

class Floor: public Object
{
public:
	size_t GetNrFlat() const;
	virtual void Print() const;
	void SetNrFlat(size_t const & nrFlat);
	Floor& operator =(Floor const & c);
	Floor (const Floor & cFloor);
	Floor();
	virtual ~Floor();
	//void AddFlat(Flat const &flat);

private:
	size_t mNrFlat;
	//TFlatList mFlatList;

};

minastaros schrieb:

Tip am Rande: Floor hat doch bestimmt einen Container, in dem die Flats drinnen sind, oder? Schau Dir mal eine Referenz dieses Containers an, was der ggf. über seine enthaltenen Objekte weiß...

wie mache ich das? oder was meinst du genau?

[...] "urform"(muss noch geändert werden) der klassenhierarchie zeigen [...]

Na wunderbar, ein Bild sagt mehr als ...

ACnut schrieb:

minastaros schrieb:

Tip am Rande: Floor hat doch bestimmt einen Container, in dem die Flats drinnen sind, oder? Schau Dir mal eine Referenz dieses Containers an, was der ggf. über seine enthaltenen Objekte weiß...

wie mache ich das? oder was meinst du genau?

Wenn Dein Container ein vector wäre, gibt es z.B. hier http://www.cplusplus.com/reference/vector/vector/ mehr Infos (sorry, der Begriff "Referenz" könnte für Dich irreführend sein), in der linken Spalte sind z.B. die eingebauten Funktionen aufgelistet. Es lohnt sich, die mal näher anzusehen um zu lernen, was vector , list usw. out of the box schon so können...

ACnut schrieb:

[...] "urform"(muss noch geändert werden) der klassenhierarchie zeigen [...]

Na wunderbar, ein Bild sagt mehr als ...

tausend Worte

Also ich hab ihn nach der Schnittstelle gefragt, zwar hat er es seler noch nicht fertig gemacht aber hier sein header (wobei ich immer noch nicht weiß was das bringt, denn mit den flats arbeite ich ja noch nicht)

class Flat // : public Object
{
public:
	// Constructor with default values :
	Flat(size_t const & dnr = 0, size_t const& size = 0, bool const & sb = false, TOwner const& name = Owner() , bool const& ho = false);

	// Copy-constructor
	Flat(Flat const & fl_cc);

	// Set door number
	void SetDoorNr(size_t const & dnr);

	// Set flat size
	void SetSize(size_t const& size);

	// Determine if the flat has a balcony or not
	void SetBalcony(bool const & sb);

	// Set owner
	void SetOwner(TOwner const& name);

	// Print the flat and its owner
	void Print(std::ostream & os) const;

	// Assignment operator overloading
	Flat & operator=(Flat const & fl);

// Members
private:
	// Door number 
	size_t mDoorNr;

	// Size of flat
	size_t mSize;

	// Boolean value to determine if the flat has a balcony or not
	bool mBalcony;

	// Flat owner (if any)
	TOwner mOwner;

	// Boolean value to determine if the flat has an owner or not
	bool mHasOwner;
};

gut auf der seite habe ich jetzt zusätzlich gelernt, dass beide container const_pointer und const referenzen eh "packen" und die funktionen die ich oft brauch, weiß ich eh noch. ich weiß immer noch nicht wie mir das jetzt weiterhilft.
habe jetzt probeweise mal beim addfloor und beim container typedef die const weggetan und jetzt krieg ich denselben fehler für "FLoor*const"

void House::Print(std::ostream&out) const
{
...
	copy(mFLoors.begin(),mFLoors.end(),ostream_iterator<Floor>(out, " "));
}

beim ostream_iterator hab ichs immer noch als FLoor gehabt (projekt war am anfang ohne zeiger auf klassen gedacht) und nicht Floor*. bin die ganze zeit fix davon ausgegangen, dass es nicht beim print legen kann und hab wo anders gesucht (woanders wo ich die copy funktion benutzt hab)