Zugreifen auf bedingt initialisierte Member-Structs

*Rewind*

Hallo zusammen,
folgende Design-Problematik: ich habe eine Klasse mit mehreren Structs als Attributen (den Begriff verwendet wahrscheinlich keiner mehr), von denen manche nur unter best. Bedingungen initialisiert werden. Nun weiß ich nicht, wie ich beim späteren Zugriff auf die Structs überprüfen soll, ob sie initialisiert sind. Ich sehe da zwei Möglichkeiten:
(a) Die Struct-Member als Heap-Zeiger _record anzulegen und mit 0 zu initialisieren. Beim Zugriff einfach if (_record) überprüfen. Weiß aber nicht, ob das überhaupt richtig ist. Der Nachteil: ich müsste einen Kopierkonstruktor, Destruktor mit Speicherfreigabe, usw. anlegen und, wenn man den zweiten Satz in dieser Antwort beachtet, die Structs im Ctor initialisieren. Weil das aber größere Operationen sind, wollte ich das mit einer separaten Methode in einem separaten Aufruf machen. Zudem bringen Variablen aufm Heap zusätzliches Risikopotential mit sich.
(b) In jedem Struct eine bool-Variable anlegen, die bei der Initialisierung des Struct auf true gesetzt wird. Nachteil: vllt. nicht das geschickteste Design?

Wie macht man das am geschicktesten?

So habe ich mir die erste Methode vorgesellt.

class Knoten : public WVObject
{
private:
	struct R1
	{
		std::string kName;
		std::string symbolName;
		float knotenEntnahme;
		float z;
		//[...]

		R1()
			:knotenEntnahme(-1.0f), z(-1.0f) {}
	} * _record1;

	struct R2
	{
		float strassenHoehe;
		//[...]
	} * _record2;

public:
	Knoten (const std::vector<std::string>& lines)
		:WVObject(lines), _record1(0), _record2(0) {};
	//copy ctor, dtor, etc.

	void parse (); //Daten auslesen, Structs initialieren
};

Initialisiere einfach immer alle Attribute. Dann brauchst du weder Zeiger noch bools und alles wird viel einfacher.
Wenn es unbedingt nötig ist Objekte mit uninitialisierten Attributen zu haben (was eigentlich nie nötig sein sollte), dann würde ich einen Zeiger nehmen. Und mit Zeiger meine ich unique_ptr oder wenn es sein muss ein shared_ptr.

*Rewind*

Das Problem wäre dann, dass es für mich nicht möglich wäre zu überprüfen, ob die Werte des Attributs gültig sind oder nicht, was aber wichtig ist, weil ich nur die Structs weiter verarbeiten (in die DB schreiben) will, die im Ausgangsdatensatz vorhanden waren. Und sobald man anfängt, das anhand der Werte von Attributen zu erkennen, ist man wieder in der Ausgangssituation (was mit bool sogar einfacher wäre zu implementieren aber es ist ja nicht nur eine Frage der Bequemlichkeit).

Ich weiß nicht wie deine Datenbank aussieht, aber wie wäre es mit einer map<Attribut_typ, Wert_typ>>, die Attribut Werte zuweist. Attribute, die es nicht gibt, sind halt nicht in der map drin. Da du mit Datenbanken arbeitest hast du bestimmt eh schon eine Textrepräsentation für alle Attribute, sodass es einen Wert_typ für alle Attribute gibt (string).
Das würde auch Operationen wie Kombinieren, Widersprüche finden usw. einfach machen.