Getter- und Setterfunktionen von Strukturfeldern

Antoras

Hallo,

ich bin gerade am überlegen wie ich am einfachsten auf meine Felder von Strukturen mit Hilfe von Gettern/Settern zugreife. Ich habe beispielsweise so etwas:

struktur1->struktur2->struktur3->struktur4->feld_x = x;

Das ist aber umständlich zu schreiben. Eine Möglichkeit wie man das mit Getter/Setter schreiben könnte wäre ja so:

setX(getStruktur4(getStruktur3(getStruktur2(getStruktur1()))), x);

Das ist ja aber genauso umständlich, da ich ja jedes mal die Struktur übergeben muss in der sich mein Feld befindet. Es gäbe noch die Möglichkeit so etwas zu realisieren:

return_typ setX(variable_typ x) {
  struktur1->struktur2->struktur3->struktur4->feld_x = x;
}

Hier hab ich aber immer das Problem, dass ich nicht dynamisch bin, also immer auf die selben Strukturen zugreifen muss.

Hab ich einen Denkfehler und kann man das ganze viel einfacher lösen (also so, dass man deutlich weniger schreiben muss), oder gibt es keine Möglichkeit diesen umständlichen Code zu umgehen wenn ich dynamisch bleiben will?
Und noch was: Macht es Sinn, sich jedes Mal undynamische Getter/Setter zu schreiben, oder wird das dann von der Menge der Funktionen zu unübersichtlich?

hi,
wennze oft sowas schreiben musst:
struktur1->struktur2->struktur3->struktur4->
dann bietet sich ein macro an:
#define S4_ struktur1->struktur2->struktur3->struktur4->
kannst dann deine member mit
S4_feld_x = x;
erreichen.

Antoras

Hallo,

stimmt, an Makros hab ich gar nicht gedacht. Guter Tipp, danke dir.

Aber ansonsten hab ich unter C keine großen Möglichkeiten mir mit Gettern/Settern das Leben großartig zu erleichtern. Sehe ich das richtig?

Antoras schrieb:

Hallo,
stimmt, an Makros hab ich gar nicht gedacht. Guter Tipp, danke dir.
Aber ansonsten hab ich unter C keine großen Möglichkeiten mir mit Gettern/Settern das Leben großartig zu erleichtern. Sehe ich das richtig?

Man kann dann jede Instanz eines bestimmten Strukturtypen an die Getter-/Setterfunktionen übergeben.
Irgendwie ist das eine Vereinfachung, oder? Vllt. aber auch nur die übliche Vorgehensweise.

Antoras

Also, dass ich sozusagen in einer Setter eine andere Setter aufrufe?
Das hört sich gut an, nur bekomme ich gerade einfach nicht raus wie das mit der Instanzübergabe genau funktionieren soll. Könntest du dazu noch ein wenig Pseudocode posten, um das noch anschaulicher zu machen?

Oder war das ganz anders gemeint?

mach doch ungefähr so:

// verschachtelte struct
struct s1
{
   struct s2
   {
      struct s3
      {
         int x;
      } s3;
   } s2;
};

int getx (struct s1 *s)
{
   return s->s2.s3.x;
}

void setx (struct s1 *s, int x)
{
   s->s2.s3.x = x;
}

...
// eine instanz der struct anlegen
struct s1 s;
// wert setzen
setx (&s, 1234);
// wert holen
printf ("%d\n", getx (&s));  // 1234
...

Antoras

Hallo fricky,

ich hab überhaupt nicht gewusst, dass man auf Strukturen, die man in anderen Strukturen erstellt von auẞen zugreifen kann. Wurde in meinen Büchern irgendwie nicht erwähnt - oder ich hab es überlesen.

Vielen Dank schon mal, das hat mir sehr weitergeholfen. Nur eine Frage hab ich jetzt noch. Weshalb benötige ich die beiden Deklarationen in Zeile 3 und 4? Warum kann ich das typedef nicht direkt in die Struktur schreiben?

#include <stdio.h>

typedef struct s2 s2;
typedef struct s3 s3;

typedef struct {
        struct s2 {
                int y;
                struct s3 {
                        int x;
                } s3;
        } s2;
} s1;

typedef struct {
        s3 s;
} s4;

int getXInS1(s1 *s) {
    return s->s2.s3.x;
}

void setXInS1(s1 *s, int x) {
    s->s2.s3.x = x;
}

int getYInS2(s2 *s) {
    return s->y;
}

void setYInS2(s2 *s, int y) {
    s->y = y;
}

int getXInS4(s4 *s) {
    return s->s.x;
}

void setXInS4(s4 *s, int x) {
    s->s.x = x;
}

int main(int argc, char **argv) {
    s1 s1;
    s2 s2;
    s4 s4;
    setXInS1(&s1, 123);
    setYInS2(&s2, 456);
    setXInS4(&s4, 789);
    printf("%d\n%d\n%d\n", getXInS1(&s1), getYInS2(&s2), getXInS4(&s4));
    return 0;
}

du brauchst die typedefs prinzipiell gar nicht. selbst wenn c ein typedef innerhalb einer struct zuließe, wäre dieser typ bloß in dieser struct sichtbar ( sichtbarkeit ).
das kann man sich anhand eines typedefs innerhalb einer funktion klar machen:

void func()
{
	typedef int aa;
	aa bb; // ok, bb ist vom typ aa, also int.
	return;
}

int main( )
{
	aa cc; // unbekannt, weil innerhalb der funktion versteckt.

	return 0;	
}

Antoras schrieb:

Nur eine Frage hab ich jetzt noch. Weshalb benötige ich die beiden Deklarationen in Zeile 3 und 4? Warum kann ich das typedef nicht direkt in die Struktur schreiben?

keine ahnung. ich glaub 'typedefs' kannste nicht verschachteln. vielleicht geht's irgendwie, aber ich hab's noch nirgends gesehen.

Antoras

vereinfach0r schrieb:

du brauchst die typedefs prinzipiell gar nicht. selbst wenn c ein typedef innerhalb einer struct zuließe, wäre dieser typ bloß in dieser struct sichtbar ( sichtbarkeit ).

Stimmt, daran hab ich gar nicht gedacht. Das typedef benutze ich eigentlich nur, damit ich nicht jedes Mal das struct benutzen muss um auf die Struktur zuzugreifen. So wie ich es jetzt habe geht es ja auch.

Nochmal vielen Dank für eure Antworten. Ihr habt mir sehr weitergeholfen. So ist das gleich ein bisschen weniger umständlich.

Ja, C ist relativ 'umständlich', wenn es um 'gewöhnliche' PC-Anwendungen geht.
Für gewöhnliche PC-Anwendungen sind andere Sprachen, hauptsächlich die objektorientierten, wesentlich besser geeignet.

Antoras

Das ist leider wahr, zumahl die objektorientierten Sprachen meist fette Libraries haben, die einem alles machen was man haben will.
Aber ich denke wenn man die ganzen "Tricks" von C mal raus hat, dass dann der Unterschied nicht mehr so groß sein dürfte. Zumahl das geile an C ja gerade ist, dass man die Mittel, die einen ans Ziel bringen, selber erstellen und sie nicht nur einsetzten muss. Noch dazu kann man Sachen programmieren, bei denen man bei anderen Sprachen nur davon träumen kann.