ich habe ein struct z.B.

struct irgendwas
{
int zeigeranfang;
int zeigerende;
int hilfszeiger;
};

Jetzt möchte in einer Funktion die Daten im struct definieren z.B.

void eineFunktion(irgendwas& irgendstru, .... )
{
irgendstru.zeigeranfang = 0; //Ist nicht immer 0
......
}

Dieses ist nur ein simples Beispiel welches mein Problem verdeutlichen soll.
Also nun soll eine Schleife von zeigeranfang bis zeigerende durchlaufen werden. Dazu ist es notwendig den Wert von zeigeranfang nicht zu verändern (für weitere Durchläufe). Dazu der hilfszeiger (zeiger ist evtl. gerade etwas unpassend gewählt). IS ist hier der entsprechende stuct:
" irgendwas IS; eineFunktion(IS, .... ); "

Bsp.:

for(IS.hilfszeiger = IS.zeigeranfang; IS.hilfzeiger != IS.zeigerende; ++IS.hilfszeiger)
{
.....
}

Wie kann ich es nun erreichen, dass zeigeranfang nachdem es definiert wurde konstant bleibt um solche Fehler zu verhindern

for(IS.zeigeranfang; IS.zeigeranfang != IS.zeigerende; ++IS.zeigeranfang)
{
.....
}

//Danach keine zweite Schleife möglich!!! Da zeigeranfang == zeigerende

Danke und Gruß

Alles andere wäre wohl ein DirtyHack: Im struct "zeigeranfang" als const definieren, die Addresse des struct herausbekommen und dann per Zeiger den Const doch zu verändern. Wenn das überhaupt die Laufzeitumgebung mitmacht...

Das Problem ist ja, dass ich den Wert für zeigeranfang erst in der Funktion bekomme. In meinem Fall sind zeigeranfang und -ende Iteratoren einer Containerliste. Der Aufwand an diese heranzukommen ist aufgrund der Struktur relativ komplex weshab ich das in der Funktion abarbeiten möchte und dann halt nur zeigeranfang und -ende als Datum des struct´s benutze. Die Funktion selber beschafft mir nur die Daten. Da ich diese Funktionalität viel benutzen muss, spare ich mir unzählige Zeilen Code.

@Braunstein:

Braunstein schrieb:

Er muß deswegen aber nicht zu einer class umsteigen. Eine struct kann das auch. Wobei hier class etwas eindeutiger wäre.

Wie mache ich das mit einem struct?

genauso wie mit einer class. class und struct unterscheiden sich ausschließlich durch die Standard-Sichtbarkeit der Member.
Wie schon gesagt must du const-Member mit dem Konstruktor initialisieren. Wenn der Member nach dem Konstruktor noch geändert werden soll darf er nicht const sein.

bis bald
akari

void Lesefunktion(const irgendwas& data,...)
{
  for(int i=data.zeigeranfang;i<data.zeigerende;++i)
    mac_was();
}

Diese Funktion darf die Member von data zwar lesen, aber nicht verändern. Da das auch 'hilfszeiger' betrifft, verwendet sie eine lokale Hilfsvariable, um durch deine Daten zu iterieren.

Also es gibt die Definition des structs:

struct MyStruct
{
int zeigeranfang;
int zeigerende;
int hilfzeiger;
};

dann die Funktion:

void eineFunktion( MyStruct& ms, /* u.v.m.... */ )
{
//z.B. eine Funktion die mir den zeigeranfang besorgt
ms.zeigeranfang = besorgmirzeigeranfang( /* u.v.m.... */ ) 
ms.zeigerende = //.......
//.......
};

Zum schluss eine Funktion, in der das alles genutzt wird: z.B.

int main()
{
MyStruct MS;
eineFunktion( MS, /* u.v.m.... */ );

for(MS.zeigeranfang; MS.zeigeranfang != MS.zeigerende; ++MS.zeigeranfang)
{
//...... Code ...
/* NUN SOLL ABER GENAU DAS NICHT MÖGLICH SEIN, DASS MAN MS.zeigeranfang ERHÖHEN KANN UM DIE INFORMATION DARÜBER NICHT ZU VERLIEREN, WO DER ANFANG DER LISTE IST.
UM DAS ZU VERMEINDEN WÄRE ES GUT, WENN MS.Zeigeranfang const WÄRE UND DAMIT DER KOMPILER FESTSTELLT, DASS MIST GEBAUT WURDE. 
NUR KANN ICH JA LEIDER zeigeranfang IN DEM struct NICHT ALS const DEKLARIEREN, DA ICH MIR DIE INFOS ERST IN DER LISTE HOLE*/ 
}

Mach die eigentlichen Membervariablen in MyStruct private und füge dafür Getter und Setter hinzu. Der Aufruf eines Setters anstatt eines Getters ist schon ein grober Fehler.

Allerdings wird mir nicht klar warum du nicht gleich ein std::vector nimmst, da ist besser als dein handgemachter schlechte Nachbau.

bis bald
akari

Ich glaube es nicht ganz klar geworden was ich will, deshalb versuche ich es noch einmal zu verdeutlichen:

Also es gibt die Definition des structs:

struct MyStruct
{
int zeigeranfang;
int zeigerende;
int hilfzeiger;
};

dann die Funktion:

void eineFunktion( MyStruct& ms, /* u.v.m.... */ )
{
//z.B. eine Funktion die mir den zeigeranfang besorgt
ms.zeigeranfang = besorgmirzeigeranfang( /* u.v.m.... */ ) 
ms.zeigerende = //.......
//.......
};

Zum schluss eine Funktion, in der das alles genutzt wird: z.B.

int main()
{
MyStruct MS;
eineFunktion( MS, /* u.v.m.... */ );

for(MS.zeigeranfang; MS.zeigeranfang != MS.zeigerende; ++MS.zeigeranfang)
{
//...... Code ...
/* NUN SOLL ABER GENAU DAS NICHT MÖGLICH SEIN, DASS MAN MS.zeigeranfang ERHÖHEN KANN UM DIE INFORMATION DARÜBER NICHT ZU VERLIEREN, WO DER ANFANG DER LISTE IST.
UM DAS ZU VERMEINDEN WÄRE ES GUT, WENN MS.Zeigeranfang const WÄRE UND DAMIT DER KOMPILER FESTSTELLT, DASS MIST GEBAUT WURDE. 
NUR KANN ICH JA LEIDER zeigeranfang IN DEM struct NICHT ALS const DEKLARIEREN, DA ICH MIR DIE INFOS ERST IN DER LISTE HOLE*/ 
}

OMFG!
dann mach doch eine Frienddeklaration von "eineFunktion"

dann kannst du in eineFunktion auf die Private-Member auch "settend" zugreifen, und die anderen User können die Get-Methoden verwenden, um ihre Daten zu bekommen ...

struct MyStruct
{
friend void eineFunktion(MyStruct &ms, /* u. v. m.*/);
int Getzeigeranfang();
int Getzeigerende();
int Gethilfzeiger();

private:
int zeigeranfang;
int zeigerende;
int hilfzeiger;

};

Hallo

Mach die eigentlichen Membervariablen in MyStruct private und füge dafür Getter und Setter hinzu. Der Aufruf eines Setters anstatt eines Getters ist schon ein grober Fehler.

Allerdings wird mir nicht klar warum du nicht gleich ein std::vector nimmst, da ist besser als dein handgemachter schlechte Nachbau.

bis bald
akari

Letztendlich ist mein Struct dann eine Klasse!?
Mein schlecher Nachbau ist ja nur ein Beispiel. Es ist letzlich nichts anderes als ein Vector mit Containern was ich wirklich habe. Die Struktur die hier vorliegt ist nur so komplex, dass ich mir um an die Iteratoren ran zu kommen eine Komponente hole diese mit einem dynamic_cast als Liste caste u.s.w.. Diesen ganzen Vorgang wollte ich in einer Funktion verstecken, da ich ihn sehr oft brauche und das u.a. den Code unleserlich macht.
Wenn ich mir jetzt ne Klasse mit getter und setter functions mache, ist das meiner Meinung nach schon wieder etwas overfeatured, so dass ich letztlich so lassen kann wie es vorher war. Ich werd mir was überlegen. Evtl. nehm ich ne Klasse.

Danke und Gruß

... class und struct unterscheiden sich ausschließlich durch die Standard-Sichtbarkeit der Member...

Nochmal, class und struct sind identisch bis auf die oben erwähnte Einschränkung.

akari schrieb:

... class und struct unterscheiden sich ausschließlich durch die Standard-Sichtbarkeit der Member...

Nochmal, class und struct sind identisch bis auf die oben erwähnte Einschränkung.

Okay, aber wenn ich dann jetzt nochmal folgendes Beispiel aufgreife:
(siehe oben)

struct MyStruct 
{ 
friend void eineFunktion(MyStruct &ms, /* u. v. m.*/); 
int Getzeigeranfang(); 
int Getzeigerende(); 
int Gethilfzeiger(); 

private: 
int zeigeranfang; 
int zeigerende; 
int hilfzeiger; 

};

habe ich doch eigentlich ne Klasse, da es ja private Meberber gibt!? Oder?

Deshalb: "Letztendlich ist mein Struct dann eine Klasse!?"

eine Klasse ist etwas, wo class davor steht.
ein Struct ist etwas, wo struct davor steht.

Wo liegt das Problem?

habe ich doch eigentlich ne Klasse, da es ja private Meberber gibt!? Oder?

Deshalb: "Letztendlich ist mein Struct dann eine Klasse!?"

Das hat nichts mit private zu tun. Meditier einfach nochmal darüber was akari und Braunstein gesagt haben.

Du must eben trennen zwischen dem Prinzip Klasse, bestimmt durch die Möglichkeiten des OOP. Und der Umsetzung in C++. Die Umsetzung wird repräsentiert durch das Schlüsselwort class... und eben auch durch das Schlüsselwort struct. Dem Compiler ist es egal wie es heißt (bis auf genannte Ausnahme).
Deshalb kann man auf deine Frage

habe ich doch eigentlich ne Klasse, da es ja private Meberber gibt!? Oder?

mit ja antworten. Man kann übrigens auch Klassenorientiert programmieren ohne auch nur einmal die Schlüsselwörter class oder struct zu verwenden.

bis bald
akari

...
habe ich doch eigentlich ne Klasse, ...

Ja - denn Du hast IMMER eine Klasse, wenn Du ein struct hast.

Stonecold_Mario schrieb:

...
...da es ja private Meberber gibt!?

Nein - auch sonst.

Merk Dir einfach:
- struct = Klasse mit Default=public
- class = Klasse mit Default=private

Ich glaube, Du stellst Dir da selbst ein Bein (vllt. weil Du ein wenig ungeübt bist im C++-Denken), wenn Du versuchst, einen philosphischen Unterschied zwischen struct und class zu definieren.

Gruß,

Simon2.