Wie kann ich Variablen im Vektor-Zugriff * obj?

Question

Wie würde ich meine Variablen aus einem Vektor?

Ich kann nicht die binären Insertion Operatoren oder die gleichen Operatoren verwenden.

Früher habe ich einen vector<someStruct> *vObj erklärt und zugeordnet er kehrte dann die vObj und nannte es in dieser Funktion:

vector<sameStruct> firstFunc();

for (unsigned int x = 0; x < v->size(); x++)
{
   v[x];
}

, wenn ich es debuggen, hat v[x] nun den gesamten Inhalt des ursprünglichen Vektors, wie es ohne den Index / Index zuvor.

Aber ich glaube nicht, dass ich irgendetwas getan haben darüber hinaus den Fortschritt.

Ich habe nur etwa 4 Variablen in meinem Vektor; wenn ich es debuggen, hat es die Informationen, die ich brauche, aber ich kann es nicht bekommen.

Answer 1

Wie es geschrieben v ist ein Zeiger auf einen Vektor von Strukturen.

Wenn Sie Index direkt in v alles, was Sie tun, ist Zeiger arithmatic. v [x] ist der Vektor von Strukturen an der Position x (die v unter der Annahme, wird ein Array, wenn es nur ein einzelne Objekt am Ende des Zeigers ist dann v [x] für x> 0 ist nur Müll). Dies liegt daran, es ist die Anwendung des [x] nicht zu dem Vektor von v wies aber auf den Zeiger v selbst.

Sie müssen die Zeiger dereferenzieren und dann Index in den Vektor mit so etwas wie:

(*v)[x];

An diesem Punkt haben Sie einen Verweis auf das Objekt in der x-ten Position des Vektors an seinen Mitgliedsfunktionen zu erhalten / Variablen verwenden:

(*v)[x].variable;

oder

(*v)[x].memberfunction(parameters);

Wenn Sie nicht wollen, zu dereferenzieren der Vektor dann das Element zugreifen innerhalb es Sie so etwas wie könnte versuchen:

v->at(x);
v->at(x).variable;
v->at(x).memberfunction;

So können Sie eine Elementfunktion eines Objekts zugreifen, auf genau die gleiche Weise wie beim genannt:

v->size();

Ich hoffe, dass dies hilft.

Answer 2

So verwenden Sie den Operator [] Elemente zugreifen, die Sie auf dem Objekt tun, so müssen, nicht einen Zeiger auf ein Objekt.

Versuchen;

(*vec)[x];

z.

for (int i = 0; i < vec->size(); i++)
{
  printf("Value at %d is %d\n", i, (*vec)[i]);
}

Beachten Sie, dass, wenn Funktionen auf einem Zeiger Aufruf verwenden Sie in der Regel der -> Operator statt dem Operator, aber man kann leicht tun (* VEC) .some_func (. ); statt.

Operatoren wie [], -, ++ und so weiter können wirken sowohl auf Objekte und Zeiger. Mit Objekten wirken sie als Funktionsaufrufe, sondern auf Zeiger wirken sie als mathematische Operationen auf die Adresse.

Zum Beispiel:

pointer[nth];
*(pointer + nth);

Haben Sie genau die gleiche Wirkung - sie kehren das n-te Objekt von Anfang des Zeigers. (Beachten Sie die Lage des * im zweiten Beispiel, nennt man das nach der Offset angewendet wird.

Zwei weitere Spitzen;

Sie können auch, indem man den Vektor als Referenz, kein Zeiger auf die Notwendigkeit zu dereferenzieren wie dies vermeiden. Es ist nicht immer eine geeignete Option, aber es ist zu saubereren Code führen.

void my_func(std::vector<int>& vector)
{
  // vector can then be used as a regular variable
}

Wenn Sie vorhaben, Vektoren eines bestimmten Typs Funktionen werden vorbei viel dann können Sie eine typedef verwenden sowohl für Klarheit und auf die Eingabe zu speichern.

typedef std::vector<int> IntVector;

void my_func(IntVector& vector)
{
}