Hilfe die Zeiger kommen !

Hm,

ohne die Definition des Structes zu kennen ist das ein wenig 
Rätselraten.


Andreas S. schrieb:
> Das heißt doch, dass gpEEPROM ein Zeiger ist und eine Adresse beinhaltet
> welche auf die erste Stelle im EEProm verweist.

Nicht so ganz, in der Struct steht noch ein wenig mehr als nur die 
Adresse im Eeprom. Warscheinlich ist das Eeprom mit Daten des Structs 
vollgeknallt und der Autor greift einfach hart auf die Adressen zu.
Das ist nicht schön, funktioniert aber unter gewissen Bedingungen.

Wie gesagt, ohne Definition des Structs...

Grüße,

Hast du dich schon mit Zeigerarithmetik und Zeigerdreferenzierung 
beschäftigt?

Zeiger sind immer wieder ein Spass auch nach Jahren, aber vielleicht 
hilft das hier:

http://openbook.rheinwerk-verlag.de/c_von_a_bis_z/012_c_zeiger_001.htm#mjee28a882ef9125d2c4cc49121b2c65c1

Da sind eigentlich alle Infos drin die du suchst... Hoffe es hilft dir!

Schau dir auch mal die "main.h", da ist die Datenstruktur "struct 
eeprom_giess" definiert auf den der Zeiger gpEEPROM nachher 
wahrscheinlich zeigen soll.

Andreas S. schrieb:

> Aber warum wurde mit der oben angeführten Definition auch ein Array
> deklariert ? gpEEPROM[index]

Weil in C Pointer und Arrays eng verwandt sind, wenn auch nicht 
identisch (bei einem Array wird Speicher für die Nutzdaten reserviert, 
bei einem Pointer nicht). Aber beim Verwenden kann man einen Zeiger 
genauso wie ein Array nutzen; man muß nur sichergestellt haben, daß 
irgendwo der Speicher alloziert wurde.

Sieht man übrigens oft, wenn man einen Pointer hat und den Speicher dann 
per malloc reserviert - und dann der Zeiger wie ein Array genutzt wird.

Oder auch, wenn man ein Array an eine Funktion übergibt - das verflacht 
dann zu einem Zeiger, weswegen man die Längeninformation dabei 
normalerweise als zusätzliche Variable mitgibt, wenn man das braucht.

> und warum wird in der Routine void print_csv das "&" verwendet wenn es
> sich doch schon um einen Zeiger handelt.

Weil dort wird erst der Zeiger dereferentiert wird, dann auc das struct 
geguckt und die Adresse von einer spezifischen Variablen rangeholt wird.

&gpEEPROM[i].pump_on im Einzelnen erklärt:

- nimm den Zeiger gpEEPROM
- addiere i-mal die Größe seines Datentyps drauf (d.h. gehe i von diesen 
structs weiter)
- bei dem struct, wo man dann ist, nimm die Variable pump_on
- und besorg Dir mit dem & davon jetzt die Adresse.

Völlig übliches C-Idiom.

1

2

if(save)

3

{

4

        eeprom_write_block(&flower, &gpEEPROM[index], sizeof(struct eeprom_giess));

5

        print_flower_setup(index, &flower);

6

}

hier wird doch der Speicherinhalt beginnend an der Adresse "&flower" + 
sizeof(struct eeprom_giess) (Typ struct eeprom_giess) aufs Eeprom 
beginnend an der Speicherstelle "&gpEEPROM[index]" + sizeof(struct 
eeprom_giess) geschrieben. Da iss doch der Zusammenhang!? Oder meinst du 
was anderes?

Die Funktion eeprom_write_block schreibt bestimmt einfach stumpf an die 
Stelle im Eeprom die angegeben ist mit der Länge sizeof(struct 
eeprom_giess).

Hast du das gemeint?

int myvar = 0; // die normale Variable brauchen wir später

1.) Deklaration und Initialisierung
int *ptr_myvar; // Zeiger vom Typ int deklarieren (zeigt noch auf nix)
ODER
int *ptr_myvar = (int *)0x0100; // deklarieren und initialisieren in 
einem an Adresse 0x0100
ODER
int *ptr_myvar = &myvar; //deklarieren und initialisieren in einem mit 
Variable myvar

2.) in der Anwendung
ptr_myvar = &myvar;  // Zeiger ptr_myvar ADRESSE von myvar zuweisen
*ptr_myvar = myvar;  // Zeiger ptr_myvar WERT    von myvar zuweisen
*ptr_myvar = &myvar; // Zeiger ptr_myvar ADRESSE von myvar als Wert 
zuweisen
ptr_myvar = myvar;   // Zeiger ptr_myvar WERT von myvar als ADRESSE 
zuweisen

Andreas S. schrieb:
> das heißt "&" bedeutet in diesem Fall Dereferentierung und neue Adresse
> ?

die funktion 'eeprom_read_block' braucht vermutlich als zweiten 
Parameter eine Adresse. Das '&' ist hier ein Adressoperator.

Andreas S. schrieb:
> das stimmt, aber gpEEPROM beinhaltet doch schon eine Adresse ??

Das hier

1

&gpEEPROM[i].pump_on

musst Du dir so denken

1

&(gpEEPROM[i].pump_on)

neben Zeigerarithmetik, Zeigerdereferenzierung musst Du dich auch 
unbedingt noch mit Operatorenprioritäten beschäftigen.

ptr_myvar = &myvar;  // Zeiger ptr_myvar ADRESSE von myvar zuweisen
*ptr_myvar = myvar;  // Zeiger ptr_myvar WERT    von myvar zuweisen

Diese beiden Beispiele werden häufig gebraucht.

*ptr_myvar = &myvar; // Zeiger ptr_myvar ADRESSE von myvar als Wert
zuweisen
ptr_myvar = myvar;   // Zeiger ptr_myvar WERT von myvar als ADRESSE
zuweisen

Diese beiden Beispiele sind SYNTAKTISCH korrekt, ergeben aber fast nie 
einen Sinn im Programmkontext.

---------------------------------

var repräsentiert den Wert der Variablen
&var repräsentiert die Adresse der Variablen

ptr_var repräsentiert die Adresse des Zeigers
*ptr_var repräsentiert den Wert, auf den der Zeiger zeigt

*var und &ptr_var sind beide syntaktisch falsch

---------------------------------

Anwendungsbeispiel:

int var[] = {0,1,2,3}  // array mit 4 Werten
int *ptr_var = var[0]; // ptr_var zeigt jetzt auf den ersten Wert im 
array
ptr_var++; // ptr_var zeigt jetzt auf den 2. Wert im array
ptr_var++; // ptr_var zeigt jetzt auf den 3. Wert im array

Obwohl ++ immer um 1 erhöht ist springt der Zeiger bei ++ um 4 Byte, da 
er vom Typ int ist. Der Zeiger "weiss" um sein Datenformat (eigendlich 
weiss es der Compiler). Bei Funktionsaufrufen kann man das nutzen, um 
nur einen Zeiger auf ein komplexes Datenformat als Parameter zu 
übergeben statt viele Einzelparameter (z.B. ein struct).
Aber nichts ohne Ausnahme:
void *ptr_var ist ein Zeiger ohne Datenformat, der auf ein beliebiges 
Format gecastet werden kann. Aber nichts überstürzen !

Victor Vector schrieb:
> *var und &ptr_var sind beide syntaktisch falsch

nein &ptr_var ist nicht falsch, das ist die Adresse des Zeigers. Kann 
man beispielsweise gebrauchen, wenn man den Zeiger by reference 
übergibt, etwa für eine verlinkte Liste, wenn die ohne 
Dummy-Head-Element realisiert ist.

Dirk B. schrieb:
> Du kannst einem Array keinen neuen Bereich zuweisen, demnach sind Größe
> und Ort fest, Post/Pre-Inkrtement geht auch nicht.

Ja sicher, das folgt ja alles daraus, daß bei einem Array auch Speicher 
alloziert wird, bei einem Pointer nicht. Das mit Inkrement ist 
allerdings ein weiterer Gesichtspunkt, ja.

Man kann aber z.B. auch einen Pointer mit den eckigen Klammern wie ein 
Array nutzen, die Klammern sind syntaktischer Zucker.

Dirk B. schrieb:
> Der Adressoperator & ergibt unterschiedliche Werte und Typen

Gut, ich hab auch noch nie bei einem Array den Adreßoperator benutzt.

> und auch sizeof() liefert andere Werte.

Ja, weil bei einem Array der Speicher alloziert wird und der Arrayname 
nur ein Alias ist, während bei einem Pointer die Größe eines Zeigers auf 
der jeweiligen Plattform zurückkommt.

Andreas S. schrieb:
> &(gpEEPROM[i].pump_on) soweit war das dann klar für mich mit Ausnahme
> der [] Klammer,
> was aber vermutlich nur bedeutet:
> &((gpEEPROM * i).pump_on - hoffe ich jedenfalls

Nee, das nicht. Der Ausdruck "gpEEPROM[i]" ist dasselbe wie *(gpEEPROM + 
i). Man kann daher "&(gpEEPROM[i].pump_on)" ohne eckige Klammern auch so 
schreiben:

&((*(gpEEPROM + i)).pump_on)

oder so:

&((gpEEPROM + i)->pump_on)

Dirk B. schrieb:
> Das geht sogar noch weiter

Ja, immer wieder gern gesehen bei obfuscated code contests. :-)


Michael .. schrieb:
> der richtigkeitshalber müsste es nicht eher so sein?

Nee, Pointerarithmetik addiert automatisch die Größe des Datentyps dazu 
und nicht Bytes. Beispiel:

Bei "char *p1" mit der Annahme p1==8 ergäbe p1+1 dann 9.
Bei uint32_t *p2 mit der Annahme p2==8 ergäbe p2+1 dann 12.

Das mit dem sizeof brauchste bei malloc, etwa um auf einen 
uint32-t-Pointer 5 uint32_t zu allozieren:

uint32_t *p3; p3 = malloc(5 * sizeof(uint32_t));

Nop schrieb:
> uint32_t *p3; p3 = malloc(5 * sizeof(uint32_t));

Ach ja, und im Unterschied dazu dann noch calloc:
p3 = calloc(5, sizeof(uint32_t));

Das ist schon ein hirnrissiger Teil der C-Standardbibliothek, daß man 
gleichartige Funktionen mit verschiedener API realisiert hat.