class Player {
  public:
    Player(string name, int money);
  private:
    string player_name;
    int player_money;
};

int main(void) {
  int i,Anzahl=10;
  vector<Player> alleSpieler(Anzahl);
  for(i=0;i<Anzahl;i++) {
    alleSpieler[i] = Player bot1("PowerBot1",1500); // hier liegt das Problem
  }
}

Player::Player(string name, int money) {
  this->player_name = name;
  this->player_money = money;
}

Player(string name, int money) : player_name(name), player_money(money) {}

du erzeugst ein array mit 10 mal "Player bot1"
ich würde eher schreiben wenn du das so willst:

int main() {    // das void weglassen
  int i,Anzahl=10;
  Player bot1("PowerBot1",1500);
  vector<Player> alleSpieler(Anzahl);
  for(i=0;i<Anzahl;i++) {
    alleSpieler[i] = bot1;  }
}

alleSpieler[i] = Player bot1("PowerBot1",1500); // hier liegt das Problem

Der Bezeichner "bot1" hat da nichts zu suchen.

Wie kann ich in der for-Schleife Instanzen/Objekte mit unterschiedlichen Namen erstellen bzw. die Objekte gleich im Array erstellen?

for(int n = 0; n < 10; ++n)
    player[n] = Player("Powerbot1", 1500);

Und bitte, bitte, bitte: Misch nicht deutsch und englisch im Code! Entweder oder...

for(int n = 0; n < 10; ++n)
    player[n] = Player("Powerbot1", 1500);

funktioniert leider nicht, ich bekomme dann die Fehlermeldung das es keine Funktion Player::Player() gibt. Ruf ich damit nicht auch eine Funktion und kein neues Objekt auf?

ich bekomme dann die Fehlermeldung das es keine Funktion Player::Player() gibt.

Aber nicht an dieser Stelle.

Verpass deiner Klasse mal einen Default-Konstruktor.

Kann mir noch versuchen zu erklären warum ich einen default-Konstruktor benötige? Ich verwende doch weiterhin überall nur den Player::Player(string name,int money) Konstruktor.

Kann mir noch versuchen zu erklären warum ich einen default-Konstruktor benötige? Ich verwende doch weiterhin überall nur den Player::Player(string name,int money) Konstruktor.

Wenn du einen Vector von 10 Player-Objekten anlegst, müssen die doch erst einmal konstruiert werden.

vector<Player> playersRed(count):
	() (copy) (copy) (copy) (copy) (copy) (copy) (copy) (copy) (copy) (copy) ~() (int) ~() (int) ~() (int) ~() (int) ~() (int) ~() (int) ~() (int) ~() (int) ~() (int) ~() (int) ~() ~() ~() ~() ~() ~() ~() ~() ~() ~() ~()   Calls: 42

vector<Player> playersGreen; + reserve(count);
	(int) (copy) ~() (int) (copy) ~() (int) (copy) ~() (int) (copy) ~() (int) (copy) ~() (int) (copy) ~() (int) (copy) ~() (int) (copy) ~() (int) (copy) ~() (int) (copy) ~() ~() ~() ~() ~() ~() ~() ~() ~() ~() ~()   Calls: 40

Viel spart vector<T>::reserve() gegenüber vector<T>(int) scheinbar nicht .. oder überseh ich da was?

pumuckl schrieb:

wenn ich das richtig im Kopf hab ist reserve fuer den Compiler eh nur eine Richtlinie, keine Regel (sprich er muss nicht unbedingt den ganzen Platz reservieren).

ist reserve ggü. resize evtl. speicherschonender. Aber ich glaube nicht, dass es viele Unterschiede in der Performance gibt.

vector<Player> playersRed(count):
	() (copy) (copy) (copy) (copy) (copy) (copy) (copy) (copy) (copy) (copy) ~() (int) op= ~() (int) op= ~() (int) op= ~() (int) op= ~() (int) op= ~() (int) op= ~() (int) op= ~() (int) op= ~() (int) op= ~() (int) op= ~() ~() ~() ~() ~() ~() ~() ~() ~() ~() ~()   Calls: 52

vector<Player> playersGreen; + reserve(count);
	(int) (copy) ~() (int) (copy) ~() (int) (copy) ~() (int) (copy) ~() (int) (copy) ~() (int) (copy) ~() (int) (copy) ~() (int) (copy) ~() (int) (copy) ~() (int) (copy) ~() ~() ~() ~() ~() ~() ~() ~() ~() ~() ~()   Calls: 40

reserve ist VIEL besser.
man muss nur eben auch alles korrekt zählen

Player& operator=(Player const& p) { std::cout<<"op= "; ++calls; return *this; }

dann aber auch:

Player& operator=(Player const& p) { std::cout<<"op= "; ++calls; return *this; }

In der Tat.
g++ hat keine Warnung geliefert - da muss man echt -Wall machen damit er hier was sagt. Gut zu wissen.

std::vector<Player> playersRed(count);

10 mal CTOR, CCTOR und DTOR aufruft, anstatt wie G++ anscheinend nur ein Objekt zu erstellen und dieses dann 9 mal zu kopieren.

Interessanterweise produziert

std::vector<Player> playersRed(count,Player());

hingegen auch nur 52 calls.

Mit VS2005 kann das fast nicht sein, da sowohl der "nur grösse" als auch der "grösse + wert" ctor intern nur die selbe _Construct_n Funktion aufrufen... Hm.
Muss mir das gleich nochmal mit VS2010 ansehen, vielleicht haben sie da die Std.Lib. geändert (also geändert wurde sicher viel, allein schon wegen Rvalue Referenzen, aber ich sehe keinen Grund die beiden hier betroffenen Konstruktoren zu ändern).

const int count = 10;
	{	// -1-
		std::vector<Player> A(count);
		for (int i = 0; i!=count; ++i)
			A[i] = Player(i);
	}
	Player::clearCount("std::vector<Player> A(count)");

	{	// -2-
		std::vector<Player> B;
		B.reserve(count);
		for (int i = 0; i!=count; ++i)
			B.push_back(Player(i));
	}
	Player::clearCount("reserve + push_back");

	{	// -3-
		std::vector<Player> C(count,Player());
		for (int i = 0; i!=count; ++i)
			C[i] = Player(i);
	}
	Player::clearCount("std::vector<Player> C(count,Player())");

	{	// -4-
		std::vector<Player> D;
		D.reserve(count);
		std::generate_n(std::back_inserter(D),count,[]()->Player{static int val = 0; return Player(++val);});
	}
	Player::clearCount("reserve + generate_n + anonym func");

	{	// -5-
		std::vector<Player> D;
		D.reserve(count);
		std::fill_n(std::back_inserter(D),count,Player(1));
	}
	Player::clearCount("reserve + fill_n");

Ausgabe:

std::vector<Player> A(count)
     CTOR: 10
CTOR(int): 10
    CCTOR: 10
     DTOR: 30
      OP=: 10
====total: [b]70[/b]

reserve + push_back
     CTOR:  0
CTOR(int): 10
    CCTOR: 10
     DTOR: 20
      OP=:  0
====total: [b]40[/b]

std::vector<Player> C(count,Player())
     CTOR:  1
CTOR(int): 10
    CCTOR: 10
     DTOR: 21
      OP=: 10
====total: [b]52[/b]

reserve + generate_n + anonym func
     CTOR:  0
CTOR(int): 10
    CCTOR: 10
     DTOR: 20
      OP=:  0
====total: [b]40[/b]

reserve + fill_n
     CTOR:  0
CTOR(int):  1
    CCTOR: 10
     DTOR: 11
      OP=:  0
====total: [b]22[/b]