Die Struktur, Die Übergabe und der Doppelpointer

beginner88888

allo Dirk, danke für die Antworten.
OK, das mit der Adresse übergeben bei dem Doppelzeiger ist mir jetzt klar.

Generell, mit der Padding-Byte Sache... Solche Funktionen zum "init" machen wie ich probiert habe, sollte man dann wohl eher in der "experimentieren" Ecke lassen und nicht verwenden?

Nochmal wegen dem Zeiger auf Struct... OK, sehe ein es geht einfach nicht, aber auf was zeigt der Zeiger denn dann, adressentypisch? Nicht auch auf eine Art "Startadresse"? Rest vom Code kann man so lassen?

Die Adresse von der struct fällt schon mit der Adresse vom ersten Element zusammen.
Nur, ist das dann (bei dir) ein rs* . Das erste Element hat int* .
Das sind unterschiedliche Zeiger.

beginner88888 schrieb:

, sollte man dann wohl eher in der "experimentieren" Ecke lassen und nicht verwenden?

So ist es.

Du gewinnst dadurch nichts.

Rest vom Code kann man so lassen?

Welchen Rest? Das ist doch alles experimentell.

Bashar

So beim oberflächlichen Lesen hab ich das Gefühl, du willst eigentlich

struct data {
  int v[4];
  /* Rest */
};

oder?

beginner88888

Ja, mit "Rest" war gemeint ob das mit dem Doppelpointer so passt, oder ob man das generell "anders" macht.

beginner88888

@Bashar, das wäre zwar das gleiche, aber genau das wollte ich nicht
Vor allem will ich die Struktur-elemente später namentlich ansprechen und nicht mir Array Index arbeiten.

Wie gesagt, die Struktur ist jettz auf das wesentliche begrenzt, soll mal so werden:

struct RS{int ID; int X; int Y; int Z; float Offset_lin; float Offset_Circ; int Status; bool Turn; char *PTP-Name; char *Err_MSG};

RS HOME, NULLFRAME;

bla bla bla

beginner88888

So, jetzt hat sich noch ne andere Unklarheit ergeben...

Und zwar habe ich jetzt ein Array of Struct, das ich übergeben will

rs buffer[50]

das "speichern" will ich in ner extra funktion machen.
Ich dachte daran einen Zeiger auf die Struktur zu übergeben , seh aber irgendwie den Wald vor lauter Bäumen nicht

foo(rs uebergabe[50])    //übergibt ... Werden Arrays nicht eh "by Reference"  übergeben

foo(rs *zeiger, size_t anzahl, FILE *datzeiger){  // beim Aufruf reicht dann der Array-name, da er Zeiger auf das erste Elemnt ist...?

int i;

for (i=0; i<anzahl, i++){
   fwrite(zeiger, sizeof(rs), 1, datzeiger);
   zeiger++;       // sollte meinen Zeiger auf das nächste Array Element erhöhen?
}
???????????

Steh gerade voll auf dem Schlauch.

Noch etwas OFF-Topic :

Warum funktioniert das :

do {
    puts("Wert eingben: \n");
    scanf("%d", &i);
}while ( ! ( (i==3) || (i==4)) );

Aber

do {
    puts("Wert eingben: \n");
    scanf("%d", &i);
}while ( (i!=3) || (i!=4) );

...bricht die Schleife nicht ab??
while i not 3 or i not 4 ...

Zu dem "Steh gerade voll auf dem Schlauch."

Ersetze die ??????????? durch }
Oder was hast du noch vor?

Du kannst auch alles auf einmal schreiben:

fwrite(zeiger, sizeof(rs), anzahl, datzeiger);

Zu OT:
Wenn du das ! in den Ausdruck reinziehst, musst du auch dsas || in && wandeln (und umgekehrt)

wenn i == 3 ist, dann ist der 3 != 4 (der zweite Ausdruck) wahr
wenn i == 4 ist, dann ist der 4 != 3 (der erste Ausdruck )wahr
Bei allen anderen Zahlen sowieso. Also ist es immer wahr.

beginner88888

Hmm... dann war der Schlauch doch nicht so groß

foo(rs uebergabe[50])

Bei dieser Methode müsste ich dann mit Index arbeiten oder?

Danke für den Tipp bzw. die Lösung meines Logik-Problems.
Jezt wo du es "ausführlich" geschrieben hast, ist es eigentlich klar, warum die Schleife nicht abgebrochen wird.

Danke!!

beginner88888 schrieb:

foo(rs uebergabe[50])
Bei dieser Methode müsste ich dann mit Index arbeiten oder?

Nein!

Zwischen

foo(rs uebergabe[50]) {...}

und

foo(rs *uebergabe)  {...}

gibt es keinen Unterschied.
Du hast keine Information darüber, wie groß der Bereich/Array ist, auf den uebergabe zeigt.

Zudem kannst du jederzeit zwischen Array- und Pointerschreibweise wechseln.

Denn wenn der Compiler im COde uebergabe[10] findet, macht er gleich *(uebergabe+10) daraus.