inkremet operator ++ auf char-arrays

hallo, hab hier folgende funktion die alle kleinbuchstaben in grossbuchstaben umsetzt.

und es geht um das s++ am funktionsende.

ist es ein unterschied ob ich

*s++;
oder
s++;

verwende? (ich stelle nämlich keinen fest wenn ich es kompiliere).
müsst es nicht s++ heisen,weil ich ja den speicherbereich um einen "block" hochzähle?

int grossSchreiben(char *s)
{
  int i=0;
  while(*s != '\0')
  {
       if(islower(*s))
       {
         *s = toupper(*s);
         i++;
       }
    s++; <--------------------
  }

  return i;
}

Das macht in diesem Falle keinen Unterschied, da dein *s nur chars enthält - also Elemente mit der Größe 1 Byte. Wenn du aber zum Beispiel Integers hast die nicht nur 1 Byte groß sind, dann musst du auch wirklich die Speicherblöcke zählen und nicht nur die Bytes!

das heist, was wäre die richtige verwendung

s++ weil ich dann die speicherblöcke hochzähle und bei *s++ jediglich um die größe des wertes im array.

fraggi schrieb:

ist es ein unterschied ob ich
*s++;
oder
s++;

ja, bei ersterem wird noch der wert ermittelt, auf den der pointer zeigt. wenn du den nicht brauchst, dann reicht s++

Swordfish

AnonymousCoder schrieb:

Das macht in diesem Falle keinen Unterschied, da dein *s nur chars enthält - also Elemente mit der Größe 1 Byte. Wenn du aber zum Beispiel Integers hast die nicht nur 1 Byte groß sind, dann musst du auch wirklich die Speicherblöcke zählen und nicht nur die Bytes!

Quatsch. Pointerarithmetik. Bei einem char* wird 1 Byte weitergezählt, bei einem int* sizeof( int ) Bytes - automatisch.

@OP: Der Dereferenzierungsoperator bindet IMHO schwächer. Damit wird der Inkrementoperator vorher auf den Pointer angewendet. Die Dereferenzierung ist schlicht unnötig.

cheers, Swordfish

s[i];
i++;

wäre wohl das sinnvollste - meiner Meinung nach

Swordfish schrieb:

@OP: Der Dereferenzierungsoperator bindet IMHO schwächer als der Inkrementoperator und wird vorher auf den Pointer angewendet.

da bindet nix, die position des '++' entscheidet, was vorher angewendet wird.

Swordfish

f*ck. Stimmt.

cheers, Swordfish

Swordfish schrieb:

Quatsch. Pointerarithmetik. Bei einem char* wird 1 Byte weitergezählt, bei einem int* sizeof( int ) Bytes - automatisch.

Wenn du den den zeiger incrementierst stimmt das wohl, das verstehe ich - also *s++ - aber wenn man nur s++ nimmt ist doch s ein normaler long und wird nur hochgezählt, oder?
Und kann es nicht auch passieren, das das Array fragmentiert ist? wenn ich dann einfach sizeof( TYP ) weitergehe bin ich irgendwo - oder verhindert so etwas der Compiler?

Swordfish

AnonymousCoder schrieb:

Wenn du den den zeiger incrementierst stimmt das wohl, das verstehe ich - also *s++ - aber wenn man nur s++ nimmt ist doch s ein normaler long und wird nur hochgezählt, oder?

Also, ganz langsam: *s++ ist gleichbedeutend mit *( s++ ) . Wenn s ein Pointer auf Typ ist, wird sizeof( Typ ) Bytes weitergezählt.

AnonymousCoder schrieb:

Und kann es nicht auch passieren, das das Array fragmentiert ist?

ISO/IEC 9899:1999 TC2 schrieb:

6.2.5 Types

[...]

An array type describes a contiguously allocated nonempty set of objects with a
particular member object type, called the element type.

Fragmentierte Arrays, WTF!?

cheers, Swordfish

Mensch, so ein C Compiler ist doch ganz schön intelligent, muss ich gerade mal so feststellen... Sry und Danke!