lesender Zugriff auf Objekt in Klasse

[Pille456]

Kann ich blub dann während des Programmablaufes dann noch ändern? Weil die Position eines Objektes z.B. ändert sich ja auch während des Programmes. So muss die Liste immer geändert werden.

[MFK]

Pille456 schrieb:

Kann ich blub dann während des Programmablaufes dann noch ändern?

Das widerspricht ein wenig dem "nur lesenden Zugriff".

[Tachyon]

Beschreibe nochmal genau, was Du überhaupt willst. Irgendwie ist das nicht klar.

[Pille456]

ich will die blub ändern können, aber die Objekte in blub nicht.
Also sowas wie "blub->SetIrgendwas()" soll nicht gehen, aber blub = anderesBlub

[Tachyon]

Dann mach blub doch private.

[Pille456]

Dann kann ich über Setter auf die Blub-Eigenschaften immernoch zugreifen.
ich will das das nicht mehr geht:

class Foo {
private: 
Foo Blub;

public:
void SetBlub(Foo pBlub);
void MachWas() {
Blub->SetBlub(this); //kann auch ein anders Blub sein; dies soll unerlaubt sein
Blub = Blub->GetBlub(); //Das soll man dürfen
}
};

[Tachyon]

Pille456 schrieb:

Dann kann ich über Setter auf die Blub-Eigenschaften immernoch zugreifen.
ich will das das nicht mehr geht:

class Foo {
private: 
Foo Blub;

public:
void SetBlub(Foo pBlub);
void MachWas() {
Blub->SetBlub(this); //kann auch ein anders Blub sein; dies soll unerlaubt sein
Blub = Blub->GetBlub(); //Das soll man dürfen
}
};

Häh?

[zwutz]

du kannst einer Klasse nicht verbieten, seine eigenen Member zu veraendern. Das einzige, was du machen kannst (und was du deiner Beschreibung nach auch machen willst) ist, den Member privat zu machen und nur einen oeffentlichen getter zur Verfuegung zu stellen.

mach doch mal ein normales Beispiel... dieses ewige Blubb , Foo usw. verbloedet einen ja richtig beim lesen

[Nexus]

Pille456 schrieb:

class Foo {
Foo blub; 
};

Es ist trotzdem nicht möglich, in einer Klasse ein Objekt des eigenen, noch nicht definierten Typs als Member zu haben...

[Pille456]

Ich will der Klasse ja nicht verbieten seine eigenen member zu verändern, sonder die aller anderen Klassen. Da das Hauptprogramm diese aber ändern können muss, muss ich getter einbauen die public sind.
@Nexus: Kann sein, dass das nicht geht, aber bei mir schluckt der Compiler dieses:

class MeineTolleKlasse;

class MeineTolleListe {
MeineTolleListe *next;
MeineTolleKlasse *klasse;
//Funktionen
};

class MeineTolleKlasse {
MeineTolleListe *listeAllerKlasseInSichtfeld; //hier dann nun die Frage ob ein pointer so sinn macht oder ich mit "const" arbeiten soll
//Funktionen etc.
//Was ich nun will ist dies: 
void machwas() {
listeAllerKlasseInSichtfeld->GetIrgendwas(); //Soll erlaubt sein
listeAllerKlasseInSichtfeld->SetIrgendwas(...); //Verboten sein
}
};

[zwutz]

wenn du einen setter verbieten willst, bau ihn doch einfach nicht ein...

[LordJaxom]

Ich glaube ich beginne zu ahnen, was Du möchtest. Es sollen also Verweise auf Objekte aus dem Hauptprogramm an dieses Objekt übergeben werden, aber das Objekt soll aus diesen Verweisen nur lesen können?

Wenn die Getter alle const-correct sind, geht sowas:

class MeineTolleKlasse {
    MeineTolleListe const* listeAllerKlasseInSichtfeld; //hier dann nun die Frage ob ein pointer so sinn macht oder ich mit "const" arbeiten soll
    //Funktionen etc.
    //Was ich nun will ist dies: 
    void machwas() {
        listeAllerKlasseInSichtfeld->GetIrgendwas(); //erlaubt
        listeAllerKlasseInSichtfeld->SetIrgendwas(...); //Verboten
    }
};

[Pille456]

Genau das LordJaxom
Wie müssen dann die Setter aussehen dafür und vorallendingen wie initialisiere ich die? Mit NULL?

[Nexus]

Pille456 schrieb:

@Nexus: Kann sein, dass das nicht geht, aber bei mir schluckt der Compiler dieses:

class MeineTolleKlasse;

class MeineTolleListe {
MeineTolleListe *next;
MeineTolleKlasse *klasse;
//Funktionen
};

Ja, aber da handelt es sich auch um Zeiger, und nicht um Objekte der eigenen Klasse.

Pille456 schrieb:

Wie müssen dann die Setter aussehen dafür und vorallendingen wie initialisiere ich die? Mit NULL?

Setter nennt man die Memberfunktionen, deren Aufgabe im Schreibzugriff auf Member besteht. Funktionen kann man nicht initialisieren, schon gar nicht mit NULL (ich denke nicht, dass du rein virtuelle Methoden meinst, bei denen die Syntax einer Null-Initialisierung gleicht).

Wie wärs, wenn du die nicht erwünschten Methoden einfach gar nicht anbieten würdest?

[Pille456]

Ah sorry, da hatte ich mich total falsch ausgedrückt...
Also ich brauche Setter um im Hauptprogramm die Eigenschaften zu ändern, daher muss ich sie implementieren.
Nun haben ich eine Liste von Objekten in meiner Klasse. Die Klasse soll auf die Eigenschaften dieser Objekte(die in der Liste enthalten sind) nur lesenden Zugriff haben, d.h. es dürfen nur Getter aufgerufen werden, keine Setter.
Das Hauptprogramm besitzt auch eine solche Liste, darf aber aus dieser Liste heraus auch die Setter-Funktionen aufrufen.

Das Initialisieren bezog ich in meinem post auf die Liste. Soll diese, für den Zugriff konstante(es dürfen keine Setter aufgerufen werden), aber an sich änderbare(die Liste kann sich ändern) Variable mit NULL initialisiert werden oder wie macht man das dann?

[Nexus]

In diesem Falle sollte die Klasse (die nur lesenden Zugriff hat), eine Const-Referenz auf die Liste enthalten. Dann können nur mit const gekennzeichneten Funktionen aufgerufen werden (also die Getter). main() kriegt dann entweder die Liste selber oder eine normale Referenz darauf, sodass auch die Möglichkeit für schreibenden Zugriff besteht.

Edit: Reicht das so? Mehr kann ich momentan auch nicht sagen, da mir der Aufbau noch nicht ganz klar ist (wo ist z.B. die Liste definiert, wo die Objekte, und welche Zusammenhänge gibt es genau?)

[Pille456]

Also in etwas sieht das so aus (Original hat dann irgendwie 5 Eigenschaften und um einiges mehr Funktionen):

class Objekte {
private:
int Eigenschaft1, Eigenschaft2;
const Liste *andereObjekte;

public:
void SetEigenschaft1(int pEigenschaft);
void SetEigenschaft2(int pEigenschaft); 
void SetListe(Liste *pListe);
int GetEigenschaft1() const; //so?
int GetEigenschaft1() const;
Liste* GetListe() const;

void Machwas();
Objekt(int pEigenschaft1, int pEigenschaft2); //Wie initialisiere ich nun "andereObjekte"?
};

/* andere Datei */
include "Objekt.h"

class Liste {
private: 
Liste *next;
Objekt *objekt;

public:
Liste* Next();
Objekt GetObjekt();
void AddObjekt(const Objekt &pObjekt) const; //<-- darf nur das Hauptprogramm 
void AddObjekt(Objekt *pObjekt); //kommt im Endeffekt auf dasselbe heraus, aber obere ist "schöner" oder? / im Oberen kann ist ja nur die übergeben Variable konstant, aber der Zugrif hinter nicht mehr oder?
//usw...
};

/* andere Datei */
int main() {
Liste *GesamteListe = ErstelleIrgendwieGesamteListe();
Objekt *EinObjekt = new (...);
EinObjekt->SetListe(ErstelleIrgendwieTeilliste(GesamteListe));
EinObjekt->machwas();
return 0;
}

[Nexus]

Pille456 schrieb:

int GetEigenschaft1() const; //so?

Ja, so ist die Funktion konstant, kann also nichts an der Klasse ändern (von Mutables mal abgesehen).

Pille456 schrieb:

Objekt(int pEigenschaft1, int pEigenschaft2); //Wie initialisiere ich nun "andereObjekte"?

Am besten per Initialisierungsliste:

Objekt(int pEigenschaft1, int pEigenschaft2)
: andereObjekte(HierWäreAndereObjekte)
{

}

Pille456 schrieb:

void AddObjekt(const Objekt &pObjekt) const; //<-- darf nur das Hauptprogramm

Aber die Funktion darf nicht const sein, weil du ja etwas an der Klasse änderst.

Pille456 schrieb:

void AddObjekt(Objekt *pObjekt); //kommt im Endeffekt auf dasselbe heraus, aber obere ist "schöner" oder? 
// im Oberen kann ist ja nur die übergeben Variable konstant, aber der Zugrif hinter nicht mehr oder?

Vielleicht solltest du dich noch ein bisschen mehr in Referenzen einlesen. Bei Parameterübergaben sind sie grundsätzlich Zeigern vorzuziehen, wo möglich. Eine Referenz selber ist immer konstant, das referenzierte Objekt je nach Angabe. Bei Zeigern verhält es sich folgendermassen:

const int* a;  // Zeiger auf const int (a ist veränderbar, *a nicht)
int const* b;  // wie oben
int* const c;  // konstanter Zeiger auf int (*c ist veränderbar, c nicht)