Simple Pointer Frage

[David H. (davidm)]

Warum wird buffer++ ohne ein * geschrieben und *data++ mit einem *
Ich verstehs einfach nicht, in beiden fällen wird der Pointer erhöht.

  void getsUSART(char *buffer, unsigned char len)
  {
    char i;    // Length counter
    unsigned char data;
  
    for(i=0;i<len;i++)  // Only retrieve len characters
    {
      while(!DataRdyUSART());// Wait for data to be received
  
      data = getcUART();    // Get a character from the USART
                             // and save in the string
      *buffer = data;
      buffer++;          <<<----- HIER    // Increment the string pointer
    }
  }
  
  void putsUSART( char *data)
  {
    do
    {  // Transmit a byte
      while(BusyUSART());
      putcUART(*data);
    } while( *data++ );  <<<----- HIER
  }

[Daniel_s (Gast)]

Hi,

data = *buffer++;

ist das gleiche wie

data = *buffer;
buffer++;

Nur kürzer geschrieben

[Garden (Gast)]

buffer++; // Der Pointer zeigt anschließend auf den nächsten Eintrag

*data++;  // Es wird zunätzlich nachgeschaut, welchen Wert der Inhalt 
hat, auf den der Zeiger zeigte.

Zu Pointern:

http://et-tutorials.de/3368/pointer-in-c/

[David H. (davidm)]

Daniel_s schrieb:

ok, nun lassen wir mal das auslesen in die data variable weg, dann 
bleibt nur ein

buffer++;

Und warum hat dieses buffer++ die selbe funktion wie ein *data++ ?

[B. S. (bestucki)]

> Und warum hat dieses buffer++ die selbe funktion wie ein *data++ ?

Weil ++ stärker bindet als *

Stichwort: Operatorrangfolge

[Yalu X. (yalu) (Moderator)]

Der Ausdruck

buffer++

liefert als Ergebnis den Wert von buffer (also eine Adresse), und als 
Nebeneffekt wird buffer anschließend inkrementiert. Oftmals wird auch 
nur der Nebeneffekt (also die Inkrementierung) dieses Ausdrucks genutzt. 
Dann schreibt man den Ausdruck einfach isoliert in eine ANweisung.

*data++

liefert wegen des *-Operators als Ergebnis das Zeichen, auf das data 
zeigt und hat als Nebeneffekt ebenfalls die Inkrementierung. Wenn auch 
hier wie im ersten Beispiel nur der Nebeneffekt genutzt würde, wäre die 
Dereferenzierung unnütz, weil das Ergebnis dieser Operation ja gleich 
anschließend weggeschschmissen wird. *data++ hätte dann also den 
gleichen Effekt wie data++ (Ausnahme: data ist als volatile 
deklariert). In deinem putsUART wird der Wert von *data++ aber 
tatsächlich verwendet, nämlich um abzufragen, ob das String-Ende 
(NUL-Zeichn) erreicht ist.

[Daniel_s (Gast)]

(*buffer)++

incrementiert die variable auf den buffer zeigt

also

 (*buffer)++ != *buffer++;

[David H. (davidm)]

data++

und

*data++

wären nun klar.

wie sieht es aus mit:

&data++

Das dürfte doch das selbe sein wie data++

es liefert die addresse von data und inkrementiert


Und wie verhält sich das anders bei volatile?

[B. S. (bestucki)]

David Mueller schrieb:
> es liefert die addresse von data und inkrementiert

Ja

Der Ausdruck

(&data)++

ist jedoch nicht zulässig, weil die ermittelte Adresse in keiner 
Variable gespeichert ist und somit nicht inkrementiert werden kann.

[Garden (Gast)]

David,
das Problem, das Du da hast, ist wahrscheinlich folgendes:

Du hast eine globale Variable data, die als unsigned char definiert ist.

In der Funktion gibt es eine weitere Variable, die auch data heißt, die 
als

char *data

definiert ist, also ein Zeiger auf ein char.

Also, nicht durcheinander werfen.

Und besser: verschiedende Namen verwenden.

[Garden (Gast)]

Sorry, die erste Variable ist nicht global, sondern in main() definiert.
Das Fazit ist aber das Gleiche: Besser unterschiedliche Namen verwenden.

[B. S. (bestucki)]

Garden schrieb:
> Sorry, die erste Variable ist nicht global, sondern in main() definiert.
> Das Fazit ist aber das Gleiche: Besser unterschiedliche Namen verwenden.

Variablen in Funktionen benenne ich nach deren Inhalt, unabhängig davon, 
ob in einer anderen Funktion (dazu zählt auch main) eine Variable gleich 
heisst. Auch wenn in einer anderen Sourcedatei eine globale Veriable mit 
dem selben Namen existiert.


Folgendes sollte man jedoch zu Gunsten der Übersichtlichkeit vermeiden:

char data;

void foo(int data){
  int i;
  for(i=0;i<data;i++){
    long data;
    /* usw. */
  }
}

[Garden (Gast)]

be stucki schrieb:
> Variablen in Funktionen benenne ich nach deren Inhalt, unabhängig davon,
> ob in einer anderen Funktion (dazu zählt auch main) eine Variable gleich
> heisst.

Du bist wahrscheinlich auch kein Programmier-Anfänger, wie der 
Frage-Steller.
Bei größeren Projekten weiß man ja auch gar nicht, wie andere ihre 
lokalen Variablen nennen. Ist auch egal.

Wenn man aber mit dem Programmieren anfängt, ist es hilfreich Variablen 
unterschiedlich zu benennen, um nicht alles durcheinader zu werfen.

[Karl H. (kbuchegg)]

David Mueller schrieb:

> Und wie verhält sich das anders bei volatile?

volatile ist hier eher Nebenschauplatz. Yalu hat es nur angeführt, damit 
ihm nicht irgendwer hinten nach in die Parade fährt und 5 Postings lang 
darüber rummosert, dass er unpräzise war.

Aber um das anzusprechen. Bei

void foo()
{
   *data++;
}

kann und wird der Compiler drauf kommen, dass die Derferenzierung 
effektiv ja nichts bewirkt, weil ja mit dem so ermittelten Wert gar 
nichts gemacht wird. Der Compiler kann also die Derferenzierung effektiv 
einfach weglassen, weil sich (aus seiner Sicht) am Programm ja nichts 
ändert.
Nun, das muss aber nicht stimmen. WEnn data ein Pointer auf eine 
Hardware ist, die auf den reinen Vorgang des Auslesens hin etwas macht 
(keine Ahnung: Sirene heult, Blinklicht geht an, etc.) dann gibt es 
einen Unterschied, denn im Falle das der Compiler optimiert, findet ja 
das eigentliche Auslesen nie statt. Und mit volatile kann man das 
verhindern. volatile ist für den Compiler quasi die Aufforderung "Keine 
Optimierungen erlaubt"

[Karl H. (kbuchegg)]

> Warum wird buffer++ ohne ein * geschrieben und *data++ mit einem *
> Ich verstehs einfach nicht,

Deine Frage ist fast so sinnvoll, wie die Frage:
Warum schreibt ein Prorgrammierer einmal die Berechnung des Umfangs 
eines Kreises so

  tmp = 2 * Radius;
  Umfang = tmp * PI;

und einmal so

  Umfang = 2 * Radius * PI;

In deinen beiden Funktionen könnte jeweils die gleiche Syntax benutzen, 
wenn man wollte. Schaun wir uns mal an, was da rauskommen würde.

Fall 1: das *data++ im puts soll beibehalten werden. Wie müsste gets 
aussehen, wenn es die gleiche Syntax benutzen will.
So

 void getsUSART(char *buffer, unsigned char len)
  {
    char i;    // Length counter
  
    for(i=0;i<len;i++)  // Only retrieve len characters
    {
      while(!DataRdyUSART());// Wait for data to be received
  
      *buffer++ = getcUART();    // Get a character from the USART
                             // and save in the string
    }
  }

warum der Programmierer das nicht gemacht hat? Keine Ahnung. Vielleicht 
hat ihn die Courage verlassen das ++ auch auf der linken Seite einer 
Zuweisung einzusetzen oder es war ihm nicht wichtig genug, weil der 
Optimizer seinen Originalcode sowieso auf diese Version zusammenkürzen 
würde. Vielleicht wollte er auch einfach nur eine Hilfsvariable haben, 
damit er mit dem Debugger rankommt.


Fall 2: Die Derferenzierung wird vom Inkrement getrennt, so wie das um 
gets gemacht ist. Wie muss dann das puts aussehen?

So

  
  void putsUSART( char *data)
  {
    char c;

    do
    {  // Transmit a byte
      while(BusyUSART());

      c = *data;
      data++;

      putcUART(c);

    } while( c );
  }

Man sieht auch: Die Einführung einer Hilfsvariablen c bringt dem Code 
eigentlich kaum Klarheit, wenn man sein C lesen kann. Sie zieht den Code 
nur unnötig in die Länge.

D.h. Ob man die eine Schreibweise benutzt oder die andere ist eigentlich 
... in diesen Fällen .... relativ egal. Das eine lässt sich in das 
andere umformen und welche Schreibweise man benutzt ist weitgehend 
Geschmackssache.

[David H. (davidm)]

vielen Dank für die Ausführliche Erklärung.

Karl Heinz Buchegger schrieb:
> void foo()
> {
>    *data++;
> }


Er würde bei einer Optimierung aber nur die Derferenzierung entfernen 
oder?
Das inkrementieren wird bei behalten?

[Karl H. (kbuchegg)]

David Mueller schrieb:
> vielen Dank für die Ausführliche Erklärung.
>
> Karl Heinz Buchegger schrieb:
>> void foo()
>> {
>>    *data++;
>> }
>
>
> Er würde bei einer Optimierung aber nur die Derferenzierung entfernen
> oder?
> Das inkrementieren wird bei behalten?

Kann man so nicht sagen.

ein vollständiges Programm

unsigned char i = 5;
static unsigned char * data = &i;

static void foo()
{
  *data++;
}

int main()
{
  foo();
}

Optimierungen laufen nach der 'AS-IF' Regel.
D.h. der Optimizer darf alles machen, solange der nach aussen 
beobachtbare Effekt derselbe bleibt.
Im obigen Programm kann der Compiler (nach dem inlinen) auch das 
Inkrementieren wegoptimieren, weil data sonst nirgends benutzt wird, es 
also keinerlei beobachtbare Effekte gibt ob es stattfindet oder nicht.