Objektreferenz in Objekt

SBond

Hallo Leute,

ist es ok, wenn ich in einem Objekt auf ein anderes referenziere (als Membervariable)? Ich fühle mich etwas unwohl dabei, da ich dann nicht 100% weiß, ob diese Referenz gültig ist (bzw. bleibt), wenn ich innerhalb des Objektes damit arbeite.

Beispiel:

class BinaryData
{
public:
	void machDies(...);
	void machDas(...);
private:
	std::vector<unsigned char> m_meineDaten;
};

class BinaryDataParser
{
public:
	BinaryDataParser(BinaryData &bd) : mp_BinaryData(bd) {}
	void parsenUndSo()
	{
	   [...] // irgendwelche Vorgänge
	   mp_BinaryData.machDies(...);
	}
private:
	BinaryData & mp_BinaryData;
};

... irgendwo im Code:

// Datenempfang
BinaryData bd;
bd.machDies();
bd.machDas();

[...]
BinaryDataParser bdp(bd);
bdp.parsenUndSo();

BinaryData beinhaltet einen Datenblock, dessen Binärdaten einen bestimmten Aufbau folgen (Type-Length-Value-Format). Das Objekt stellt dafür einige Grundfunktionen bereit. Nun habe ich einen Datenblocktyp, der weitere Operationen erfordert. Dazu würde ich ein neues Objekt (hier: BinaryDataParser) erzeugen und intern auf das andere Objekt ('BinaryData') referenzieren.

Eine Kopie von 'BinaryData' möchte ich gerne vermeiden.

Ist das vorgehen so ok?

Also wenn du schreibst "irgendwo im Code", meinst du bestimmt in einem Block {}. Sobald der Block verlassen wird, wird das Objekt zerstört. Deine Referenz kannst du dann vergessen.
Wenn du Objekte über den Scope hinaus am Leben erhalten willst, brauchst du dynamische Speicherverwaltung (smart pointer + ~~new~~ make_XXX).

DNKpp

Prinzipiell hat "out" recht. Allerdings kommt es darauf an, wo deine Objekte erstellt werden.
Gehört deine BinaryDataParser einem "tieferen" Scope an, als es BinaryData tut, dann ist alles gut. Du musst dafür nicht zwingend den Heap nutzen.

Womit er recht hat, ist die Tatsache, dass wenn du Objekte über den Scope hinaus benutzen willst, den Heap nutzen musst.

Um dir mal ein Beispiel zu zeigen (Foo und Bar sind typische Beispielnamen).

struct Foo
{

};

struct Bar
{
	Foo& foo;
};

void machWasMitFoo(Foo& _foo)
{
	Bar bar{_foo};
}

Bar gibMirBar()
{
	Foo foo;
	return Bar{foo};
}

int main()
{
	// das ist ok
	Foo foo;
	machWasMitFoo(foo);

	// das ist schlecht!	Das Foo Object besitzt eine geringere Lebenszeit als Bar.
	auto bar = gibMirBar();

	// der Vollständigkeit halber: das ist auch ok, da foo länger existiert als bar2
	Bar bar2{ foo };
}

SBond

Also das Objekt wird im selben scope verwendet. Daher ist es erstmal kein Problem. Ich hatte erst die Überlegung, ob nan das irgendwie mit einem SmartPinter lösen sollte.

DNKpp

SBond schrieb:

Also das Objekt wird im selben scope verwendet. Daher ist es erstmal kein Problem. Ich hatte erst die Überlegung, ob nan das irgendwie mit einem SmartPinter lösen sollte.

Dann ist das völlig ok. Da brauchst du keinen smart_ptr!

Wie soll man dir da weiterhelfen, sieh zu, dass die Refernz gültig bleibt.

Du könntest auch ne Referenz auf einen Pointer abgeben, wenn die Referenz nicht mehr gebraucht wird, kannst du den Pointer auf NUll setzen und dann immer genau das testen, aber das ist ein echter Kackstil.

Sieh einfach zu, dass sie gültig bleibt.