explizite Typumwandlung

[sternst]

Was genau stört dich eigentlich an der Variante mit der lokalen Variable?
Das ist eine saubere und vor allem auch gut lesbare Lösung. Und weniger effizient wird sie auch nicht sein. Würde mich wundern, wenn die zusätzliche Variable auch im Binärcode als solche auftauchen würde.

[Felix G]

Ähm...
wieso tut ihr euch das überhaupt an!?

Pointerarithmetik ist ja schön und gut, aber in 99% aller Fälle geht es auch sehr viel bequemer:

void uart_send(void* data, uint16_t size)
{
   uint16_t n;
   uint8_t* data8 = (uint8_t*)data;

   for(n=0; n<size; n++)
      uart_putc(data8[n]);
}

oder alternativ:

void uart_send(void* data, uint16_t size)
{
   uint16_t n;

   for(n=0; n<size; n++)
      uart_putc(((uint8_t*)data)[n]);
}

Ja, es ist eine Zählvariable dazugekommen, aber dafür ist der Code leichter lesbar und weniger fehleranfällig.
(Außerdem wird n niemals im Speicher existieren, der Compiler verwendet einfach ein Register dafür)

[Siro]

Hallo Stefan,
meine gefundene, oben gezeigt Lösung ist ja auch "saubere Sache" und auch "sehr gut lesbar" da stimmen wir völlig überein.
So benutze ich es zur Zeit auch.
Aber wenn ich mich schon in eine neue Programmiersprache reinarbeite, möchte ich auch möglichst viele Details kennen lernen.
Deshalb kommen halt solche Fragen auf. Ich möchte immer aufs Bit genau wissen was passiert, das liegt in der jahrelangen
Programmierung in Assembler, da stört mich jede zusätzliche Variable oder Zeile.
Optimiert ein Compiler heutzutage auch lokale Variablen weg ?. Möglich wäre es ja. Aber das wäre sicher ein anderes Thema....

Aber mal generell. Kann man denn überhaupt ein Variable "vorher" casten, die mit einem Postincrement/Postdecrement verarbeitet wird.
Denn wenn ich mir die Kommenatre hier so ansehe, führt der Compiler "zuerst das "increment" durch und dann castet er.
Wie kann ich ihm denn beibringen, dass er "erst casten" soll und dann das Postincrement. Geht das überhaupt ?
Das ist rein zum Verständnis, ich möchte da sicher keine Wissenschaft draus machen.
Mir ist anscheinend (ganz sicher sogar) noch nicht klar, wie der Compiler den Code interpretiert.
Den Kommentaren nach von rechts nach links. Das kann aber so auch nicht sein,
dann würde x=*p++; falsch laufen. Wenn er erst incrementieren würde und dann den Wert zuweist.
Also muss er sich doch erst den Wert holen um ihn x zuzuweisen und dann darf er den pointer incrementieren.
Wie soll man das also casten, daß sichergestellt ist, daß der pointer nur um eins incrementiert wird.

Auch wenns nervt Ich Danke Dir
Siro

[Siro]

Hallo Felix G,
Oho, das funktioniert schon mal. Hab ich gleich mal ausgetestet.
Und ja, Du hast recht, für "n" wird ein Register verwendet, zumindest bei meinem Compilat.
Das man einen Pointer wie ein Array benutzen kann, war mir noch nicht klar.
Hat sich also mein Beitrag gelohnt. Ich bedanke mich.

Der Vollständigkeit halber nochmal 4 Lösungen:

void uart_send(void* data, unsigned int size)
{ char *p = data;

  while (size--)
  {  
    uart_putc(*p++);
  }  
} 

void uart_send(void* data, unsigned int size)
{ int i;
  
  for (i=0; i< size; i++)
  {  
    uart_putc(((char*)data)[i]);
  }  
} 

void uart_send(void* data, unsigned int size)
{ 
  while (size--)
  {  
    uart_putc(*(char*)data);
    data = (char*)data+1;
  }  
} 

void uart_send(void* data, unsigned int size)
{ 
  while (size--)
  {  
    uart_putc(*(char*)data);
    ++(*((char**)(&data)));
  }  
}

Siro

[PicNick]

Ich hab das jetzt mit dem VC (microsoft visual studio 2005) durchprobiert. Das sollte eigentlich schon auf GCC übertragbar sein.

Vorweg:

int*  p = (char*)1000;           // geht garnicht, verständlich, ist ja auch ein widerspruch

Klammervarianten:

int*    p  = (int*)1000;

         (char*)p++;              // kennen wir schon, liefert p+4
         (int)p++;                   // ebenfalls
       p = (int*)(int)p++;      // ebenfalls

      ((char*)p)++;          // Mag er garnicht ==>    error C2105: '++' needs l-value
                                  

Was geht ? (definitiv getestet)

int    tmp = (int)p;
   p = (int*)++temp;              

union { int* p;  int iP; } un;
      un.p = (int*)1000;
      un.iP++ ;     // (durch die union wird auch   int*p  mit-incrementiert

und die grausliche Variante

     p = (int*)((int)p + 1);

Wie gesagt: getestet

[danimath]

Sooo grauslich finde ich es gar nicht: Das hier (klick) hatte ich schon die ganze Zeit im Hinterkopf

viele Grüße
Andreas