class Foo {
Foo blub; 
void SetBlub(const Foo &pBlub) const; //blub soll durch Setter (im Hauptprogramm) veränderbar sein, aber nicht aus der Klasse Foo heraus
};

Danke!

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

Das widerspricht ein wenig dem "nur lesenden Zugriff".

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
}
};

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?

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

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...

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
}
};

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
    }
};

@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?

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?

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?)

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;
}

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)