[C] Pointeroperationen in C

[Der Jan]

Zitat von Hador:

Code:

   
   /* i = p1 + p2; */ /* Funktioniert nicht, da der *-Operator nicht für zwei Pointer definiert ist */

   [...]
}

Das würde auch gehen, wenn du p2 vorher nach int castest, allerdings ein Sinn dafür fällt mir aktuell nicht ein.

[Hador]

Zitat von Der Jan:

Ähm nicht ganz p[5] liefert das Feldelement mit dem Index 5, also das 6te Element zurück, allerdings ist der Ausdruck falsch, wenn auch syntaktisch richtig. feld[2] -> hier kann es dier ganz schnell mal ne AV raushauen, schau dir mal die Definition von feld an.

Der Pointer zeigt doch schon auf das erste Element und wenn ich ihn dann um fünf Elemente verschiebe zeigt er auf das Sechste
Aber ich werde es noch mal etwas deutlischer aufschreiben.

Zitat von Der Jan:

Edit: Vielleicht solltest du die Frage auch mal im CPP-Forum stellen, dort tummeln sich die C/C++ Experten

Jo, mal sehen. Sollte ich öfters Fragen in diese Richtung haben, so werde ich das auch wohl machen, aber für einmal wollte ich micht nicht noch extra irgendwo anmelden.

Zitat von Der Jan:

Zitat von Hador:

Code:

   
   /* i = p1 + p2; */ /* Funktioniert nicht, da der *-Operator nicht für zwei Pointer definiert ist */

Das würde auch gehen, wenn du p2 vorher nach int castest, allerdings ein Sinn dafür fällt mir aktuell nicht ein.

Casten ist nicht. Die Zuweisungen sind gegeben. Sonst würde man ja auch alles irgendwie durch den Compiler bekommen

[Flocke]

Code:

int main(void) {
   int feld[1];
   int i;
   int *p;
   int *p1;
   int *p2;

   p = feld; /* Funktioniert, da feld ein Pointer auf das erste Arrayelement ist und es sich um ein Integerarray handelt */

Dein Kommentar ist korrekt.

Code:

   /* feld = p; */ /* Funktioniert nicht, da p nicht zwangsläufig auf ein Integerarray zeigt (Aber auf einen int und das wäre ja das selbe, wie ein einelementiges Array, oder?) */

Funktioniert nicht, weil "feld" als Symbol einen konstanten Wert hat (also kein L-Wert ist).

Code:

   p = &feld[3]; /* der &-Operator liefert einen Pointer auf das vierte Arrayelement zurück */

Der &-Operator liefert die Adresse eines Ausdrucks, und feld[3] ist das vierte Array-Element. Somit ist deine Aussage korrekt.

Code:

   feld[2] = p[5]; /* p[5] liefert den um fünf mal Integergröße veschobenen Pointer zurück */

Die Indizierung eines Zeigers basiert in C immer auf der Größe des Datentyps, auf den der Zeiger zeigt. Bei einem "int*" werden jeweils "int"-Element indiziert. "p[5]" liefert keinen Zeiger zurück, sondern direkt den Wert des 6ten Elements des Arrays, auf das p zeigt.

Code:

   p1 = p2 + i; /* Der Zeiger wird um einen Integerwert verschoben */

Deine Aussage ist korrekt.
Auch hier gilt die Aussage von oben: die Addition einer Zahl zu einem Zeiger basiert auf der Größe des Datentyps, auf den der Zeiger zeigt. Somit ist "p[5]" von oben gleichwertig mit "*(p + 5)".

Code:

   p1 = i + p2; /* Auch hier wird der Zeiger verschoben */

Deine Aussage ist korrekt.

Code:

   /* Bei folgenden Zuweisungen bin ich mir recht unsicher: */
   /* i = p1 * p2; */ /* Funktioniert nicht, da der *-Operator nicht für zwei Pointer definiert ist */

Deine Aussage ist korrekt.

Code:

   i = p1 - p2; /* Wieso ist - denn für zwei Pointer definiert? */

Genauso wie die Addition eines Zeigers und eines Integer-Wertes wieder einen Zeiger liefert, liefert die Subtraktion zweier Zeiger einen Integer-Wert: nämlich den, den du zum zweiten Zeiger hinzuzählen müsstest um den ersten Zeiger zu erhalten. Beispiel:

Code:

p = &feld[3];
i = p - feld; // i hat jetzt den Wert 3

p1 = &feld[3];
p2 = &feld[5];
i = p2 - p1;  // i hat jetzt den Wert 2

p1 = feld + 3;
p2 = p1 + 4;
i = p2 - p1;  // i hat jetzt den Wert 4

Code:

   /* i = p1 + p2; */ /* Funktioniert nicht, da der *-Operator nicht für zwei Pointer definiert ist */

Die Addition ist für zwei Zeiger nicht definiert.

[Apollonius]

Wir haben hier klassich aneinander vorbei geredet. Ich dachte, die Aussage

Zitat:

p[5] liefert das Feldelement mit dem Index 5, also das 6te Element zurück

bezöge sich auf einen falschen Index. Anscheinend bezog sie sich aber darauf, dass der Array-Indizierungs-Operator gleichzeitig auch dereferenziert.

[Macci]

Zitat von Apollonius:

Doch, Hador hat recht. p[5] = *((int*)((int)p + 5*4))

So ist das aber Quatsch (p kann nicht als int-Wert gecastet werden).

Es geht doch ganz einfach:

Code:

p[5] == *(p+5)

Viele Grüsse,
Macci

[Der Jan]

Zitat von Hador:

Zitat von Der Jan:

Ähm nicht ganz p[5] liefert das Feldelement mit dem Index 5, also das 6te Element zurück, allerdings ist der Ausdruck falsch, wenn auch syntaktisch richtig. feld[2] -> hier kann es dier ganz schnell mal ne AV raushauen, schau dir mal die Definition von feld an.

Der Pointer zeigt doch schon auf das erste Element und wenn ich ihn dann um fünf Elemente verschiebe zeigt er auf das Sechste
Aber ich werde es noch mal etwas deutlischer aufschreiben.

Es wird hier aber kein Pointer irgendwohin verschoben, nicht ein Stückchen ! Mit "p[n]" bekommst du das n-te Element des Feldes zurück, in deinem Fall ein int, und keinen Pointer, wie nun schon mehrfach erwähnt.....

[Der Jan]

Zitat von Macci:

Zitat von Apollonius:

Doch, Hador hat recht. p[5] = *((int*)((int)p + 5*4))

So ist das aber Quatsch (p kann nicht als int-Wert gecastet werden).

Es geht doch ganz einfach:

Code:

p[5] == *(p+5)

Viele Grüsse,
Macci

Es wird langsam echt abenteuerlich hier

@Appolonius: Nix für ungut, aber akzeptier doch einfach, was p[n] bedeutet, anstatt immer wildere Casts zu entwerfen.

@Macci: Mann kann p als int casten, auch wenn der Sinn des Ganzen gegen Null geht und nein, es ist kein Wortspiel, ich meine nicht NULL.

"*4" --> Augen auf! Nicht auf jedem System ist sizeof(int) == 4

[Macci]

Zitat von Der Jan:

@Macci: Mann kann p als int casten, auch wenn der Sinn des Ganzen gegen Null geht und nein, es ist kein Wortspiel, ich meine nicht NULL.

Nein, im Allgemeinen wird das nicht funktionieren. Nur auf manchen Maschinen und nur unter manchen Übersetzern kann ein Zeiger als int-Wert gecastet werden. (siehe im Standardwerk "Programmieren in C", Kap. 5.6 "Zeiger sind keine ganzzahligen Werte", S. 111).

Edit: Auf "manchen" ist untertrieben, es funktioniert schon auf den meisten (nicht jedoch auf allen). Aber es ist ganz schlechter Programmierstil.

Viele Grüsse,
Macci

[Der Jan]

@Macci: Ok, ich muß halt noch einen nachlegen (nicht persönlich nehmen).... Theorie und Praxis, das kennt man ja. Egal, was in dem Standardwerk auf Seite 4711 geschrieben steht, ich habe noch kein System erlebt, auf dem es nicht ging, denn, auch wenn die Theorie was anderes sagt, ist in der Praxis ein Pointer eine Adresse, welche nichts anderes ist, als ein xx-bit-Integer.

Aber, wie schon erwähnt, der Sinn des ganzen Rumgecastes geht in diesem Fall gegen Null (nicht NULL)