im Moment kämpfe ich mit dem guten alten Gültigkeitsbereich.
Folgender Code gibt mir Scope-Errors:

...Definition von MyClass...

void load(){

MyClass* mc = new MyClass(argumente);
mc->func();
mc->func2();

}
//bis hierhin ist alles ok

int main(){

load(); //ok
mc->func3(); //FEHLER, unknown reference

}

Wie schaffe ich es, außerhalb der load() Funktion weiterhin mit den darin erstellten Objekten (Objektzeigern) zu arbeiten?

Danke im Voraus

Einfach den Zeiger zurückgeben?

Besser: Gar nicht so etwas programmieren. Ein mit new erstelltes Objekt über einen rohen Zeiger aus einer Funktion herausgeben ist äußerst unsauber und provoziert Fehler en masse.

Die wahre Frage ist daher, was hier erreicht werden soll, nicht wie der Threadersteller sich die technische Umsetzung vorstellt. Es gibt garantiert eine deutlich bessere Lösung.

Ja klar bei einem objekt geht das noch. Aber wenn die anzahl der objekte die in der funktion erstellt werden unbestimmt viele sind. Wenn es zum beispiel 50 sind und wenn man dann noch ein neues erstellen will, also das 51. Objekt erstellen will, wie gebe ich eine variable anzahl zurück sozusagen?

Mein Hinweis ist soeben 5 Stufen relevanter geworden.

#include <vector>

std::vector<object> gimme_more_objects()
{
  std::vector<object> v;
  ...
  return v;
}

int main()
{
  auto v = gimme_more_objects();
}

Was ist das und wie geht das?

cooky451 schrieb:

#include <vector>

std::vector<object> gimme_more_objects()
{
  std::vector<object> v;
  ...
  return v;
}

int main()
{
  auto v = gimme_more_objects();
}

Was ist das und wie geht das?

Ich hoffe das bezieht sich auf auto
Sonst lern lieber erstmal richtig C++..
Vector

Kralo9notloggedin schrieb:

cooky451 schrieb:

#include <vector>

std::vector<object> gimme_more_objects()
{
  std::vector<object> v;
  ...
  return v;
}

int main()
{
  auto v = gimme_more_objects();
}

Was ist das und wie geht das?

Ich hoffe das bezieht sich auf auto
Sonst lern lieber erstmal richtig C++..
Vector

Ja kannst du es mir bitte anhand meines codes zeigen?

#include <iostream>
#include <vector>

std::vector<int> gimme_more_objects()
{
  std::vector<int> v;
  for (int i = 0; i != 100; ++i)
    v.push_back(i);
  return v;
}

int main()
{
  std::vector<int> v = gimme_more_objects();
  for (std::size_t i = 0; i != v.size(); ++i)
    std::cout << v[i] << '\n';
}

Um zu verstehen wie vector das macht, solltest du die Grundlagen von Klassen, Operatorüberladungen und Templates kennen.

Der Speicher wird sicher in seinem Destruktor freigegeben, das kannst du also auch nicht mehr vergessen.

Bzw.: "...das kannst Du nun getrost vergessen."

Also wie ich es verstehe ist vector ein behälter wo ich die erstellten objekte aneinanderhänge. In die spitzen klammer kommt der klassenname und dann kann ich den container zurückgeben?

In den spitzen Klammern steht der Template-Parameter. Heißt der Typ der Objekte, die der vector verwalten soll.

Stillmrkralo schrieb:

Arbeite ich dann mit dem. Ontainer oder kann ich direkt mit dem inhalt arbeiten?

Die Frage macht nicht wirklich Sinn, aber ich versuche mal darauf zu antworten. Du arbeitest mit dem Container. Der hat z.B. Methoden wie .push_back(), .size(), .erase(), etc. Eine vollständige Auflistung findest du in einer Referenz.
http://en.cppreference.com/w/cpp/container/vector
Trotzdem kannst du natürlich auf einzelne Elemente zugreifen. z.B. über den operator []. v[0] greift auf das erste, v[1] auf das zweite Element etc. zu. Du darfst natürlich nur bis maximal v[v.size() - 1] zugreifen. Wie bei einem Array halt.

Bzw. Hab ich mit vector einen dynamischen array der mitwächst?

Hab ich dOch so schon richtig verstanden.
Aber ich hab dann keine möglichkeit mehr, mit den "richtigen" objektnamen zu arbeiten? Sprich mc, wie es in meinem code am anfang stand.

Der Zugriff auf einen Vektor könnte dann z.B. mit

cout<<Startbutton.v[12];

erfolgen.

Std::vector<MyClass> load(){

std::vector<MyClass> v;

MyClass* mc = new MyClass;
//einstellungen vornehmen für mc
mc->setName("startgame");
v.push_back(mc);

MyClass* mc2 = new MyClass;
//einstellungen vornehmen für mc2
mc->setName("settings");
v.push_back(mc2);

return v;
} 

Int main(){

std::vector v = load();

For(int i = 0; i < v.size() - 1; i++){
if(v[i].getName() == "settings"){
//settings wurde gefunden hurra
//arbeite mit diesem
}

return 0;
}

Man kann diese suchschleife in eine funktion packen, der man den suchstring und den vector übergibt und die dann die arraynummer zurückgibt.

Etwa so:

Int getArrayNum(std::string, std::vector){...}

SeppJ schrieb:

Besser: Gar nicht so etwas programmieren. Ein mit new erstelltes Objekt über einen rohen Zeiger aus einer Funktion herausgeben ist äußerst unsauber und provoziert Fehler en masse.

Wenn ich den Code richtig verstehe, ist die Anwendung von new doch gar nicht
notwendig.
Du kannst ein Objekt doch einfach so erzeugen, also z.B.:

myclass mc;
myclass mc2;

Hinzu kommmt, wenn ich das richtig verstehe, ist der von Dir erzeugte Vektor nur
innerhalb der Funktion gültig. Du gibst den Vektor zwar mittels return zurück, das ist aber für das weitere Arbeiten eher nicht so gut, da der Vektor dann nur noch temporär gültig ist.

Besser wäre vemutlich den Vektor ausserhalb der Funktion,aber innerhalb der Klasse zu erzeugen.
Dann kannst Du eine Funktion schreiben, den Vektor als Referenz übergeben und dann innerhalb der Funktion damit arbeiten.

MyClass mc;
...
v.push_back(mc);

Und die objekte kann ich dann immernoch, mit arraynummer, erreichen?
Behandle ich dann v[] als objekt oder pointer. Wahrscheinlich als poitner wenn er den speicher selbst anlegt, oder?

Dann muss ich drauf so referenzieren:

v[getArrayNum("schiessmichtotichversteheswohlimmernochnicht", v)]->setName("oderdoch?");