Ich besitze ein Objekt namens Node. Dieses Objekt enthält einen Vektor m_position_dblvec.

Node.h

class Node
{
private:
	std::vector<double> m_position_dblvec;
	std::vector<double>* ptr_m_position_dbl;
public:
        std::vector<double>* positionOfNode(void);
}

Node.cpp

Node::Node(GNG_Parameters &gng_parameters, NodePool &nodepool)
{
	// Initialize Positions of Array
	for(int i = 0; i < *gng_parameters.getDimensionOfInputData(); ++i)
	{ 
		m_position_dblvec.push_back(createHazardValues());	
	}
        ptr_m_position_dbl = &m_position_dblvec;

}

Innerhalb meines Codes können viele dieser Nodes erzeugt werden (und auch wieder gelöscht). Ich kann von anderen Klassen aus auf ein Node-Objekt zugreifen und eben auf diesen Vektor zugreifen.

Bisher mache ich es wie folgt:

std::vector<double>* Node::positionOfNode(void)
{
	return ptr_m_position_dbl;
}

Erhalte also einen Pointer auf den Vektor.
Wie kann ich nun über diesen Vektor, von dem ich ja jetzt nur einen Pointer besitze iterieren?

Wieso kann ich nicht einfach eine Referenz auf den Vektor übergeben? Würde dies gehen, oder ist es nicht möglich wenn ich während der Laufzeit viele solcher Nodes erstelle?

Zu deinem Problem: Willst du wirklich einen Zeiger auf den std::vector zurückgeben? Damit kann man alles damit anstellen. Ich würde den Zugriff beschränken, und z.B. in Lese- und Schreibzugriff aufteilen. Eine Referenz wäre schöner, aber man hätte immer noch das gleiche Problem mit den zu lockeren Zugriffrechten.

Aber wieso hast du in der Klasse einen std::vector als Member und einen Zeiger darauf? Wenn du unbedingt einen Zeiger zurückgeben willst, was ich dir nicht rate, kannst du das ja mit dem Adressoperator tun.

Du solltest dir vielleicht auch die ungarische Notation ein bisschen abgewöhnen, ptr_m_position_dbl ist beispielsweise hässlich zu lesen und sagt nicht mehr über die Variable aus, als man durch Darüberfahren mit der Maus erfahren würde (bei modernen IDEs). Denk dir lieber einen aussagekräftigeren Namen aus, der auch etwas über den Inhalt verrät, dafür kannst du dbl , vector und ptr raus lassen.

Ich lasse mir jetzt eine const Referenz auf den Vector zurück geben.
Aber auch da ist eine liste ja mal wieder sinnvoller...werde also auch hier die Liste einsetzen, da ich ja keinen indexzugriff auf die Elemente benötige.

Ich lasse mir jetzt eine const Referenz auf den Vector zurück geben.

Ich weiss nicht, ob das so eine gute Idee ist. Damit ist nur garantiert, dass der Container von aussen nicht verändert wird. Aber es können alle Elemente gelesen werden. Brauchst du das? Oder willst du nur gerade die Position ausgeben, bei der ein Iterator steht? Dann wäre es vielleicht angebracht, einen Iterator als Member zu speichern und dann das entsprechende Element zurückzugeben. Aber bevor ich hier weiterrate, könntest du ein wenig ausführlicher erläutern, worauf du von ausserhalb der Klasse genau zugreifen willst?

redbomber schrieb:

Aber auch da ist eine liste ja mal wieder sinnvoller...werde also auch hier die Liste einsetzen, da ich ja keinen indexzugriff auf die Elemente benötige.

Du meinst sicher std::list ?