C Progr.. warum Klammern

[Felix G]

Fassen wir mal zusammen, daß man C nicht mögen muss, und es gibt durchaus Einiges was man (aus heutiger Sicht) hätte besser machen können...
aber wenn man sich ernsthaft damit auseinandersetzt (bzw. beruflich auseinandersetzen muss), wird man früher oder später auch die Vorteile der Sprache erkennen.


Sich Merkzettel zu schreiben ist für Einsteiger sicherlich sinnvoll, und ich finde es ein bischen schade daß das hier in der Diskussion ein bischen untergegangen ist. Ich hätte auch gleich einen Korrekturvorschlag zu dem geposteten "void casting Infoblatt", denn das ist nicht 100% fehlerfrei:

Diese beiden Zeilen sind nicht äquivalent:

n = (unsigned char*) Testdata;
n = &Testdata;

Zunächst mal ist der Typ von TestData ohnehin schon "unsigned char*", denn TestData ist ein Pointer auf das erste Element des Arrays. Der Typecast in der ersten Zeile ist also unnötig. Die zweite Zeile liefert die Adresse von TestData, also die Adresse des Pointers auf das erste Element des Arrays, &TestData hat also den Typ "unsigned char**". Das kann auch durchaus gewünscht sein, aber in 99% der Fälle ist die erste Zeile die richtige.

[Siro]

Hallo Felix G
Danke für deine Rückmeldung auf das "void casting"
ich wollte jetzt nicht extra dafür einen neuen Thread aufmachen, deshalb frage ich gleich hier:

Warum sind die beiden folgenden Zeilen nicht equivalent ?
Wo liegt der Fehler, bzw. was habe ich noch nicht richtig verstanden ?

n = (unsigned char *) TestData; // Adresse setzen
n = &TestData; // oder so, geht auch

Ich habe mal folgendes ausprobiert und bekomme stets das gleiche Ergebnis. bzw. zeigt mein "void pointer n" nach jeder Zeile immer auf die gleiche Adresse.

unsigned char TestData[]={0x00,0x01,0x02,0x03};
void *n;

n = TestData;
n = &TestData;
n = (unsigned char*) TestData;
n = (unsigned int*) TestData;
n = (signed int*) TestData;
n = (int*) TestData;

Es wird lediglich der Zeiger n, welcher vom typ void* ist, auf die Adresse von TestData gesetzt. Die Typwandlung ist hier, wie Du schon sagtest nicht erforderlich, zudem ist ein void pointer generell zu jedem anderen Zeiger kompatibel. Das Entscheidende für mein Verständis waren die folgenden Zeilen: bzw. suchte ich nach einer Möglichkeit ++ bzw -- auf void pointer anzuwenden. Und dies war, logischerweise, nur mit einem entsprechenden casting möglich.

n = (unsigned char *) n+1; // Zeiger + 1 Byte
n = (unsigned short *) n+1; // Zeiger + 2 Bytes
n = (unsigned int *) n+1; // Zeiger + 4 Bytes

++p muss dann so:

n = (unsigned char *) n+1;

oder so:

++(*((char**)(&n)));

codiert werden, wenn es sich um ein Byte Zeiger handeln soll.

mfg. Siro

[BurningWave]

n = (unsigned char *) n+1;

Mach daraus mal:
((unsigned char *) (n))++;
Das muss funktionieren, wenn n++ nicht geht.

n = TestData;
n = &TestData;
Diese beiden Zeilen sind nicht äquivalent, da letzteres n einen Zeiger auf einen Zeiger, der auf TestData zeigt, zuweist.

[Felix G]

Ich habe mal folgendes ausprobiert und bekomme stets das gleiche Ergebnis. bzw. zeigt mein "void pointer n" nach jeder Zeile immer auf die gleiche Adresse.

unsigned char TestData[]={0x00,0x01,0x02,0x03};
void *n;

n = TestData;
n = &TestData;
n = (unsigned char*) TestData;
n = (unsigned int*) TestData;
n = (signed int*) TestData;
n = (int*) TestData;

Also diese Zeilen müssen alle das selbe Ergebnis liefern, mit einer Ausnahme:

n = &TestData

Bei dieser Zeile wird n die Adresse von TestData zugewiesen, bei allen anderen der Wert. Bei Typecasts muss man bedenken, daß sie dem Compiler nur vorgaukeln eine Variable hätte einen anderen Typ als es tatsächlich der Fall ist.

Während also die Zeile mit dem & Operator tatsächlich die Adresse von TestData liefert, sagen alle anderen Zeilen nur "behandle TestData so als wäre es ein int*/unsigned char* etc. etc."

[p_mork]

[quote="Felix G"]

n = &TestData

Bei dieser Zeile wird n die Adresse von TestData zugewiesen, bei allen anderen der Wert."

Es wird überall die Adresse von TestData zugewiesen, denn der Wert von TestDate ist bereits die Adresse. Ich glaube du verwechselst da Arrays mit Pointern. Wenn TestData ein Pointer wäre, wäre der Wert von TestData und &TestData verschieden, da &TestData ein Pointer auf den TestData Pointer wäre. In diesem Beispiel ist TestData jedoch ein Array und das & macht rein garnichts.

MfG Mark

[BurningWave]

In diesem Beispiel ist TestData jedoch ein Array und das & macht rein garnichts.

Das stimmt nicht. In allen Beispielen wird die Adresse von TestData zugewiesen, aber in diesem Fall, die Adresse von der Adresse, also entsteht ein Doppelzeiger vom Typ unsigned char**.

[Felix G]

Es wird überall die Adresse von TestData zugewiesen, denn der Wert von TestDate ist bereits die Adresse. Ich glaube du verwechselst da Arrays mit Pointern.

Nein, tue ich nicht...
Selbstverständlich ist in diesem Beispiel der Wert von TestData auch schon eine Adresse, aber das spielt keine Rolle. Denn &TestData liefert die Adresse von TestData und das ist eben nicht die in TestData gespeicherte.

Bei Pointern und Typecasts, gerade wenn void* im Spiel ist, sollte man schon wissen was man tut. Denn da kann man sich leicht Bugs einfangen, die ohne JTAG Adapter nur sehr schwer zu entdecken sind.

[PicNick]

Alle mir geläufigen C mit und ohne plusplus liefern bei Angabe eines Array OHNE Indexangabe die (Anfangs) adresse des Array, wenn die Zielvariable irgendeine Art von Pointer ist
das ist das "&" in der Tat doppelt gemoppelt.
Brenzlig wird es, wenn ich schreibe z.B
TestData[0] oder &TestData[0]
da ergibt das ampersand einen wesentlichen Unterschied

[BurningWave]

Wobei &TestData[0] das Gleiche ist, wie TestData, da der []-Operator den Speicherbereich dereferenziert. (Ich bin mir gerade nicht sicher, ob das funktioniert, aber dementsprechend müsste TestData[0] das Gleiche, wie *TestData sein, also der Wert des 1. Elements.)

[PicNick]

Denke nicht. *TestData gilt nur (und hat Sinn), wenn TestData ein pointer wäre.

Das Beispiel mit dem "&" wirkt imho verwirrender, als die Sache ist, weil "TestData" als Array definiert ist.

Anschaulicher und verständlicher wäre es, "TestData" sozusagen als normale Variable zu definieren,

unsigned char   TestData;
void*  n;
 
     n = (void*) TestData               // inhalt Testdata
     n = (void*) &TestData             // adresse  TestData

wobei das herum-Casten mit verschiedenen Pointer-type aus der ob. Liste wiederum wirkungslos ist´, wenn "n" ein void-pointer ist. Damit fängt der Compiler im Moment nix an.

Das casten von "n" kriegt Sinn und ist notwendig, wenn ich danach mit "n" irgendwelche operationen ausführen will, also z.B, inkrementieren von "n" selbst oder eben das, wo er hinzeigt.