Zeigerarithmetik für ungültigen Zeiger in C.

Wenn ein Zeiger auf einen bestimmten Typ (sagen wir int, char, float, ..) erhöht wird, wird sein Wert durch die Größe dieses Datentyps erhöht. Wenn ein voidZeiger, der auf Daten mit einer Größe xzeigt, inkrementiert wird, wie kann er dann xBytes nach vorne zeigen? Woher weiß der Compiler, dass er xden Wert des Zeigers erhöht?

Endgültige Schlussfolgerung: Arithmetik auf a void*ist sowohl in C als auch in C ++ illegal .

GCC erlaubt es als Erweiterung, siehe Arithmetik ein void- und Funktionszeiger (beachten Sie, dass dieser Abschnitt Teil des Kapitels "C-Erweiterungen" des Handbuchs ist). Clang und ICC erlauben wahrscheinlich void*Arithmetik zum Zwecke der Kompatibilität mit GCC. Andere Compiler (z. B. MSVC) lassen das Rechnen nicht zu void*, und GCC verbietet es, wenn das -pedantic-errorsFlag angegeben ist oder wenn das -Werror-pointer-arithFlag angegeben ist (dieses Flag ist nützlich, wenn Ihre Codebasis auch mit MSVC kompilieren muss).

Der C-Standard spricht

Zitate stammen aus dem Entwurf n1256.

In der Standardbeschreibung der Additionsoperation heißt es:

6.5.6-2: Zusätzlich müssen entweder beide Operanden einen arithmetischen Typ haben oder ein Operand muss ein Zeiger auf einen Objekttyp sein und der andere muss einen ganzzahligen Typ haben.

Die Frage hier ist also, ob void*es sich um einen Zeiger auf einen "Objekttyp" handelt oder ob voides sich um einen "Objekttyp" handelt. Die Definition für "Objekttyp" lautet:

6.2.5.1: Typen werden in Objekttypen (Typen, die Objekte vollständig beschreiben), Funktionstypen (Typen, die Funktionen beschreiben) und unvollständige Typen (Typen, die Objekte beschreiben, denen jedoch Informationen fehlen, die zur Bestimmung ihrer Größe erforderlich sind) unterteilt.

Und der Standard definiert voidals:

6.2.5-19: Der voidTyp umfasst einen leeren Wertesatz ; Es ist ein unvollständiger Typ, der nicht abgeschlossen werden kann.

Da voides sich um einen unvollständigen Typ handelt, handelt es sich nicht um einen Objekttyp. Daher ist es kein gültiger Operand für eine Additionsoperation.

Daher können Sie keine Zeigerarithmetik für einen voidZeiger ausführen .

Anmerkungen

Ursprünglich wurde angenommen, dass void*aufgrund dieser Abschnitte des C-Standards Arithmetik zulässig ist:

6.2.5-27: Ein Zeiger auf void muss dieselben Darstellungs- und Ausrichtungsanforderungen haben wie ein Zeiger auf einen Zeichentyp.

Jedoch,

Dieselben Darstellungs- und Ausrichtungsanforderungen sollen Austauschbarkeit als Argumente für Funktionen, Rückgabewerte von Funktionen und Gewerkschaftsmitglieder implizieren.

Das bedeutet also, dass printf("%s", x)es die gleiche Bedeutung hat, ob es xeinen Typ char*oder hat void*, aber es bedeutet nicht, dass Sie mit a rechnen können void*.

Anmerkung des Herausgebers: Diese Antwort wurde bearbeitet, um die endgültige Schlussfolgerung widerzuspiegeln.

Zeigerarithmetik ist für void*Zeiger nicht zulässig .

Wirf es auf einen Zeichenzeiger und erhöhe deinen Zeiger um x Bytes vorwärts.

Der C-Standard erlaubt keine Arithmetik mit leeren Zeigern. Allerdings GNU C wird unter Berücksichtigung der Größe der erlaubten nichtig heißt 1.

C11-Standard §6.2.5

Absatz - 19

Der voidTyp umfasst einen leeren Wertesatz; Es ist ein unvollständiger Objekttyp , der nicht abgeschlossen werden kann.

Das folgende Programm funktioniert im GCC-Compiler einwandfrei.

#include<stdio.h>

int main()
{
    int arr[2] = {1, 2};
    void *ptr = &arr;
    ptr = ptr + sizeof(int);
    printf("%d\n", *(int *)ptr);
    return 0;
}

Möglicherweise erzeugen andere Compiler einen Fehler.

void *Genau aus diesem Grund können Sie keine Zeigerarithmetik für Typen durchführen!

Sie müssen es in einen anderen Zeigertyp umwandeln, bevor Sie Zeigerarithmetik ausführen.

Leere Zeiger können auf einen beliebigen Speicherblock verweisen. Daher weiß der Compiler nicht, wie viele Bytes inkrementiert / dekrementiert werden müssen, wenn eine Zeigerarithmetik für einen ungültigen Zeiger versucht wird. Daher müssen leere Zeiger zuerst auf einen bekannten Typ typisiert werden, bevor sie in eine Zeigerarithmetik einbezogen werden können.

void *p = malloc(sizeof(char)*10);
p++; //compiler does how many where to pint the pointer after this increment operation

char * c = (char *)p;
c++;  // compiler will increment the c by 1, since size of char is 1 byte.

Der Compiler kennt den Typ Cast. Gegeben a void *x:

• x+1fügt ein Byte hinzu x, Zeiger geht zu Bytex+1
• (int*)x+1fügt sizeof(int)Bytes hinzu , Zeiger geht zu Bytex + sizeof(int)
• (float*)x+1Adressbytes sizeof(float)usw.

Obwohl das erste Element nicht portierbar ist und gegen das Galateo von C / C ++ verstößt, ist es dennoch C-sprachrichtig, was bedeutet, dass es auf den meisten Compilern zu etwas kompiliert wird, für das möglicherweise ein entsprechendes Flag erforderlich ist (wie -Wpointer-arith).