Was bedeutet das: Ein Zeiger auf void wird niemals gleich einem anderen Zeiger sein?

Einer meiner Freunde wies auf den zweiten Aufzählungspunkt aus “Verstehen und Verwenden von C-Zeigern – Richard Reese, O’Reilly-Veröffentlichungen” hin, und ich konnte das nicht erklären Erste Satz daraus. Was vermisse ich?

Zeiger auf ungültig

Ein Zeiger auf void ist ein Allzweckzeiger, der verwendet wird, um Verweise auf beliebige Datentypen zu halten. Ein Beispiel für einen Zeiger auf void ist unten dargestellt:

void *pv;

Es hat zwei interessante Eigenschaften:

• Ein Zeiger auf void hat die gleiche Darstellung und Speicherausrichtung wie ein Zeiger auf char.
• Ein Zeiger auf void wird niemals gleich einem anderen Zeiger sein. Jedoch wurden zwei void-Zeiger a zugewiesen NULL Wert wird gleich sein.

Dies ist mein Code, nicht aus dem Buch, und alle Zeiger haben denselben Wert und sind gleich.

#include <stdio.h>

int main()
{
  int a = 10; 
  int *p = &a; 
  void *p1 = (void*)&a;
  void *p2 = (void*)&a;

  printf("%p %p\n",p1,p2);
  printf("%p\n",p);
  
  if(p == p1) 
    printf("Equal\n");
  if(p1 == p2) 
    printf("Equal\n");  
}

Ausgabe:

 0x7ffe1fbecfec 0x7ffe1fbecfec
 0x7ffe1fbecfec
 Equal
 Equal

TL/DR: Das Buch ist falsch.

Was vermisse ich?

Nichts, soweit ich sehen kann. Sogar die in Kommentaren präsentierte Erratum-Version …

Ein Zeiger auf void wird niemals gleich einem anderen Zeiger auf void sein.

… wird von der C-Sprachspezifikation einfach nicht unterstützt. Soweit sich der Autor auf die Sprachspezifikation stützt, wäre der relevante Text Absatz 6.5.9/6:

Zwei Zeiger sind genau dann gleich, wenn beide Nullzeiger sind, beide Zeiger auf dasselbe Objekt (einschließlich eines Zeigers auf ein Objekt und ein Unterobjekt an seinem Anfang) oder Funktion sind, beide Zeiger auf eins nach dem letzten Element desselben Arrays sind Objekt, oder einer ist ein Zeiger auf einen hinter dem Ende eines Array-Objekts und der andere ist ein Zeiger auf den Anfang eines anderen Array-Objekts, das zufällig unmittelbar auf das erste Array-Objekt im Adressraum folgt.

void ist ein Objekttyp, wenn auch ein “unvollständiger”. Zeiger auf void die gültig und nicht null sind, sind Zeiger auf Objekte, und sie werden unter den durch die Spezifikation ausgedrückten Bedingungen miteinander verglichen. Üblicherweise werden solche Zeiger erhalten, indem ein Objektzeiger eines anderen (Zeiger-)Typs in konvertiert wird void *. Das Ergebnis einer solchen Konvertierung zeigt immer noch auf dasselbe Objekt wie der ursprüngliche Zeiger.

Meine beste Vermutung ist, dass das Buch die Spezifikation falsch interpretiert, um anzuzeigen, dass Zeiger auf void nicht als Zeiger auf Objekte interpretiert werden sollten. Obwohl es Sonderfälle gibt, die nur für Zeiger auf gelten voidbedeutet dies nicht, dass allgemeine Bestimmungen, die für Objektzeiger gelten, nicht auch für void-Zeiger gelten.

C 2018 6.5.9 6 sagt:

Zwei Zeiger sind genau dann gleich, wenn beide Nullzeiger sind, beide Zeiger auf dasselbe Objekt (einschließlich eines Zeigers auf ein Objekt und ein Unterobjekt an seinem Anfang) oder Funktion sind, beide Zeiger auf eins nach dem letzten Element desselben Arrays sind Objekt, oder einer ist ein Zeiger auf einen hinter dem Ende eines Array-Objekts und der andere ist ein Zeiger auf den Anfang eines anderen Array-Objekts, das zufällig unmittelbar auf das erste Array-Objekt im Adressraum folgt.

Angenommen, wir haben:

int a;
void *p0 = &a;
void *p1 = &a;

Dann wenn p0 und p1 „auf dasselbe Objekt zeigen“, p0 == p1 muss als wahr gewertet werden. Man könnte den Standard jedoch so interpretieren, dass a void * zeigt auf nichts, solange es a ist void *; Es enthält nur die Informationen, die erforderlich sind, um es wieder in seinen ursprünglichen Typ zu konvertieren. Aber wir können diese Interpretation testen.

Betrachten Sie die Spezifikation, dass zwei Zeiger gleich sind, wenn sie auf ein Objekt und ein Unterobjekt an seinem Anfang zeigen. Das bedeutet, dass gegeben int a[1];, &a == &a[0] sollte als wahr gewertet werden. Allerdings können wir nicht richtig verwenden &a == &a[0]weil die Beschränkungen für == für Zeiger erfordern, dass die Operanden auf kompatible Typen zeigen oder dass einer oder beide a sind void * (mit Qualifikationsmerkmalen wie const erlaubt). Aber a und a[0] haben weder kompatible Typen noch sind sie es void.

Die einzige Möglichkeit für eine vollständig definierte Situation, in der wir Zeiger auf dieses Objekt und sein Unterobjekt vergleichen, besteht darin, dass mindestens einer der Zeiger in eines der beiden umgewandelt wurde void * oder auf einen Zeiger auf einen Zeichentyp (weil diese bei Konvertierungen besonders behandelt werden). Wir könnten den Standard so interpretieren, dass er nur letzteres meint, aber ich halte das für die vernünftigere Interpretation void * ist enthalten. Die Absicht ist das (void *) &a == (void *) &a[0] ist als Vergleich eines Zeigers auf das Objekt zu interpretieren a zu einem Zeiger auf das Objekt a[0] obwohl sich diese Zeiger im Formular befinden void *. Also diese beiden void * als gleich vergleichen sollten.

Der folgende Abschnitt aus diesem C11-Standardentwurf widerlegt die aufgestellte Behauptung vollständig (sogar mit der in den ‘Errata’ erwähnten Klarstellung, im Kommentar von GSerg).

6.3.2.3 Zeiger

1 Ein Zeiger auf void kann in oder von einem Zeiger auf einen beliebigen Objekttyp konvertiert werden. Ein Zeiger auf einen beliebigen Objekttyp kann in einen Zeiger auf umgewandelt werden void und wieder zurück; das Ergebnis soll mit dem ursprünglichen Zeiger verglichen werden.

Oder dieser Abschnitt aus demselben Normentwurf:

7.20.1.4 Integer-Typen, die Objektzeiger enthalten können

1 Der folgende Typ bezeichnet einen vorzeichenbehafteten Integer-Typ mit der Eigenschaft, auf die jeder gültige Zeiger zeigt void kann in diesen Typ konvertiert und dann wieder in einen Zeiger auf konvertiert werden voidund das Ergebnis wird mit dem ursprünglichen Zeiger verglichen:

intptr_t

Ein Zeiger ist nur eine Adresse im Speicher. Zwei beliebige Zeiger sind gleich, wenn sie NULL sind oder auf dieselbe Adresse zeigen. Sie können immer weiter darüber reden, wie das mit der Sprache der Strukturen, Gewerkschaften und so weiter geschehen kann. Aber am Ende ist es einfach nur Algebra mit Speicherorten.

• Ein Zeiger auf void wird niemals gleich einem anderen Zeiger sein. Jedoch wurden zwei void-Zeiger a zugewiesen NULL Wert wird gleich sein.

Seit NULL in dieser Aussage erwähnt wird, halte ich es für einen Tippfehler. Die Aussage sollte so etwas wie sein

• Ein Zeiger auf void wird niemals gleich sein NULL Zeiger. Jedoch wurden zwei void-Zeiger a zugewiesen NULL Wert wird gleich sein.

Das bedeutet, dass jeder gültige Zeiger auf void niemals gleich ist NULL Zeiger.