lerne mich gerade in cpp ein schreib dafür eine kleine anwendung um den umgang mit referenzen zu üben. Allerdings habe ich dabei ein problem.

// main.cpp

#include <iostream>

using namespace std;

class spieler {
  public:
    string   name, vorname;
    spieler(string n, string v);
    ~spieler();
};

spieler::spieler(string n, string v) {
  name = n;
  vorname = v;
  cout << name << ", " << vorname << endl;
}

spieler::~spieler() {
}

class szene {
  public:
    szene(spieler &s);
    ~szene();
    void setSpieler(spieler &s);
  private:
    spieler & sp;
};

szene::szene(spieler &s) {
  sp = s;
  cout << sp.vorname << endl;
}

void szene::setSpieler(spieler &s) {
  sp = s;
  sp.vorname = "Hans";
}

szene::~szene() {
}

int main() {

  spieler s1("Wurst", "Karl");
  szene sz1(s1);
  sz1.setSpieler(s1);
  cout << s1.name << ", " << s1.vorname << endl;

  return 0;
}

Bitte nicht über die Namensgebung wundern, ist für ein größeres Projekt.

Mein Problem: ich möchte gerne in der Klasse "szene" eine Referenz auf ein Objekt der Klasse "Spieler" haben, allerdings sagt der compiler mir:
main.cpp: In constructor ‘szene::szene(spieler&)’:
main.cpp:32: error: uninitialized reference member ‘szene::sp’

ich verstehe darunter, das er die Referenz nicht initialisiert ist.

Was soll ich tun, oder hab ich ein verständnisproblem. Vielen Dank schonmal für eure Hilfe.

Referenzen dürfen nur einmal belegt und dann nicht mehr umgebogen werden.
Das würdest du aber mit sp = s machen.

Referenzen müssen also vor Ausführung des Konstruktors initialisiert werden.
Dafür gibt es die Initialisierer-Liste(hoffe habs richtig geschrieben )

Gruß
Don06

Don06 schrieb:

Referenzen dürfen nur einmal belegt und dann nicht mehr umgebogen werden.
Das würdest du aber mit sp = s machen.

Klar dürfen Referenzen "umgebogen" werden. Durch die Initialisierungsliste
wird nur die Initialisierung garantiert. Eine Referenz muss nunmal
initialisiert werden, was dadurch sichergestellt wird.

class A{

public:
	A(int& j, int k): i(j){
		i=k;
	}
	~A(){}

private:
	int& i;
};

int main(){
	int j=1;
	int k=2;
	A a(j, k);
	return 0;
}

Gruß,
CSpille

Referenzen dürfen nur einmal belegt und dann nicht mehr umgebogen werden.

ja

Das würdest du aber mit sp = s machen.

nein

Klar dürfen Referenzen "umgebogen" werden.

falsch

Durch die Initialisierungsliste wird nur die Initialisierung garantiert. Eine Referenz muss nunmal initialisiert werden, was dadurch sichergestellt wird.

richtig

CSpille schrieb:

class A{
	  
public:
	A(int& j, int k): i(j){
		i=k;
	}
	~A(){}

private:
	int& i;
};

int main(){
	int j=1;
	int k=2;
	A a(j, k);
	return 0;
}

Un das hat was mit poes Problem zu tun?

@poe: Benutz keine Referenzen als Klassenmember, wenn du sie nicht unbedingt benötigst. Hier ist ein Zeiger angebracht.

Eine Referenz ist ein Aliasname für eine bereits existierende Variable. Eine Referenz existiert also nicht allein. Sie ist immer an eine Variable gebunden.

http://tutorial.schornboeck.net/referenzen.htm

Was ist denn besser, Zeiger oder Referenzen. Ich hab mich hier als erstes für Referenzen entschieden weil mir die Syntax besser gefiel. Als nächstes bräuchte ich jetzt einen vector von Referenzen. Macht das sinn?

Gruß
Pö

Nur damit ich keinen Planungsfehler begehe. Macht es Sinn, oder ist es Möglich, die später erzeugten Objekte in eine Datei zu speichern und werden dabei auch die Zeiger beibehalten. D.h. ich hab eine reihen von Objekten erstellt die irgendwie zwischeneinander aufeinander zeigen, diese Objekte zu speichern?

Weis zwar nicht genau wie das geht, aber das es geht nehme ich einfach mal von anderen programmiersprachen ausgehend an. Z.b. kann man in Java Objekte einfach in eine Datei speichern und nachher wieder laden.

Es geht mir hier nur um die Frage, ob die Zeiger in den Objekten auch gespeichert werden können, bzw. ob sie richtig gespeichert werden.

Stichwort XML wäre hier vielleicht nicht falsch angebracht, allerdings ist das für meine Zwecke erstmal zu weit gedacht.

Gehts oder gehts nicht?

schönen Abend noch,

gruß
Pö