Objektpointer und der Gültigkeitsbereich...

kralo9

Zunächst einmal geht es ja nur um das einfache Anwenden, nicht um das detaillierte Verständnis eines Klassentemplates (was Vektoren ja sind).

Und wie würde das dann bei meiner Idee aussehen?!

redrew99

kralo9 schrieb:

Ich gebe aber doch keinen rohen zeiger, sondern den Container zurück

Ja, und soweit ich das weiß, wird dann der komplette Vektor übergeben, anstatt nur eine Referenz oder ein Zeiger darauf. Bei größeren Vektoren kann das durchaus
spürbare Geschwindigkeitsnachteile zur Folge haben.
Hinzu kommt, der Vektor als Rückgabewert ist im Prinzip nur noch temporär gültig.
Weiteres Arbeiten damit dürfte ziemlich umständlich, wenn nicht sogar unmöglich sein.

cooky451

redrew99 schrieb:

Ja, und soweit ich das weiß, wird dann der komplette Vektor übergeben, anstatt nur eine Referenz oder ein Zeiger darauf. Bei größeren Vektoren kann das durchaus
spürbare Geschwindigkeitsnachteile zur Folge haben.

Falsch, siehe RValue-Referenzen und RVO.

redrew99 schrieb:

Hinzu kommt, der Vektor als Rückgabewert ist im Prinzip nur noch temporär gültig.
Weiteres Arbeiten damit dürfte ziemlich umständlich, wenn nicht sogar unmöglich sein.

Quatsch.

@kralo9

#include <iostream>
#include <string>
#include <vector>

struct mystruct
{
  std::string name;
  mystruct(std::string name)
    : name(std::move(name))
  {}
};

std::vector<mystruct> gimme_more_objects()
{
  std::vector<mystruct> v;
  v.push_back(mystruct("Hallo"));
  v.push_back(mystruct("Welt!"));
  return v;
}

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

kralo9

Auf die geschwindigkeit kommt es mir hier nicht an, da die texturen nur bei programmstart geladen werden. Also die funktion wird nur einmal aufgerufen.
Und ganz nebenbei: wenn das laden ewig dauert wirkt mein spiel wie eins der professionell enteickelten wie die von ea und so :D:D

redrew99

kralo9 schrieb:

Zunächst einmal geht es ja nur um das einfache Anwenden, nicht um das detaillierte Verständnis eines Klassentemplates (was Vektoren ja sind).

Und wie würde das dann bei meiner Idee aussehen?!

Z.B.

void test(vector<int>&myvector,int &a)
{
  myvector.push_back (a);
}

kralo9

cooky451 schrieb:

@kralo9

#include <iostream>
#include <string>
#include <vector>

struct mystruct
{
  std::string name;
  mystruct(std::string name)
    : name(std::move(name))
  {}
};

std::vector<mystruct> gimme_more_objects()
{
  std::vector<mystruct> v;
  v.push_back(mystruct("Hallo"));
  v.push_back(mystruct("Welt!"));
  return v;
}

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

Dazu 2 fragen:
Was bringt beim konstruktor beim initialisieren der variable name das std::move? Mir wäre name(name) geläufiger..

Wieso wird in main der vectortyp als v gekennzeichnet? Ein vector in einem vector? Woher weiss er was v ist? Das muss doch fehler geben!

Edit. Ach du hast das schon geändert

cooky451

kralo9 schrieb:

Was bringt beim konstruktor beim initialisieren der variable name das std::move? Mir wäre name(name) geläufiger..

Das move ist C++11 Kram, damit wird der Speicher einfach übergeben, und keine Kopie angelegt. Ist für dich aber vielleicht erstmal egal.

redrew99

cooky451 schrieb:

int main()
{
  std::vector<mystruct> v = gimme_more_objects();
}

Welchen Sinn macht es bei dem Beispiel, erst einen Vektor innerhalb einer Funktion zu erzeugen und diesen dann einem neuen Vektor zuzuweisen?

Warum den Vektor nicht gleich ausserhalb der Funktion erzeugen und per Referenz/Zeiger übergeben?

kralo9

redrew99 schrieb:

cooky451 schrieb:
int main()
{
  std::vector<mystruct> v = gimme_more_objects();
}
Hier wird aber doch der aus der Funktion zurückgegebene Vektor einem neuen
Vektor zugewiesen.

Wäre eine Funktion mittels Übergabe des Vektors als Referenz nicht besser?

Nein weil der vector nach der rückgabe seinen gültigkeitsbereich verlässt und man somit eine referenz auf nix erhählt bzw auf irgendwas. Aber nicht das was man will.

redrew99

kralo9 schrieb:

Nein weil der vector nach der rückgabe seinen gültigkeitsbereich verlässt und man somit eine referenz auf nix erhählt bzw auf irgendwas. Aber nicht das was man will.

Richtig, man soll den Vektor ja auch ausserhalb der Funktion erzeugen und ihn dann per Referenz übergeben.

cooky451

redrew99 schrieb:

Warum den Vektor nicht gleich ausserhalb der Funktion erzeugen und per Referenz/Zeiger übergeben?

Weil's anders hübscher ist.

kralo9

Super! Jetzt funktioniert es.

Hier nochmal mein jetziger Code:

class Button {
protected:

//Hier ein paar Variablen etc.

public:

	void SetName(std::string);
	std::string GetName();

	bool SetTexture(std::string);
	bool SetHoverTexture(std::string);
        bool OnHover(std::string);
	void SetPosition(float, float);

        //Und noch ein paar mehr Funktionen...

};

std::vector<Button> Loader::LoadButtons() {

	std::vector<Button> v;

	//Spiel starten Button

	v.push_back(Button());
	v[v.size() - 1].SetTexture("Data/mm_startgame.tga");
	v[v.size() - 1].SetHoverTexture("Data/mm_startgame_hover.tga");
	v[v.size() - 1].OnHover("Data/meteor_damaged.ogg");
	v[v.size() - 1].SetPosition(400, 300);
	v[v.size() - 1].SetName("startbutton");

	return v;
}

unsigned int getArrayNum(std::string searchstring, std::vector<Button> v) {

	for (unsigned int i = 0; i != v.size(); i++) {
		if (v[i].GetName() == searchstring)
			return i;
	}

	//Fehler, gebe 0 zurück

	return 0;

}

Loader loader;

int main(){

std::vector<Button> vButton = loader.LoadButtons();

//Ab jetzt kann ich fast wie gewohnt mit den Buttons arbeiten:

vButton[getArrayNum("startbutton", vButton)].Draw(App);
...
}

Noch eine Frage zu:

unsigned int getArrayNum(std::string searchstring, std::vector<Button> v) {

	for (unsigned int i = 0; i != v.size(); i++) {
		if (v[i].GetName() == searchstring)
			return i;
	}

	//Fehler, gebe 0 zurück

	return 0;

}

Kann ich den Parameter std::vector<Button> nicht verallgemeinern? Wenn ich vielleicht mehrere Klassenvektoren auf diese Weise untersuchen möchte?
Wäre das gültig:

template<class T> unsigned int getArrayNum(std::string searchstring, std::vector<T> v) {

	for (unsigned int i = 0; i != v.size(); i++) {
		if (v[i].GetName() == searchstring)
			return i;
	}

	//Fehler, gebe 0 zurück

	return 0;

}

Also kompilieren tut er ohne Fehler und funktionieren tut das Programm auch.