Was sind die Regeln für das Umsetzen von Zeigern in C?

K & R geht nicht darüber hinweg, aber sie benutzen es. Ich habe versucht zu sehen, wie es funktionieren würde, indem ich ein Beispielprogramm geschrieben habe, aber es lief nicht so gut:

#include <stdio.h> 
int bleh (int *); 

int main(){
    char c = '5'; 
    char *d = &c;

    bleh((int *)d); 
    return 0;  
}

int bleh(int *n){
    printf("%d bleh\n", *n); 
    return *n; 
}

Es wird kompiliert, aber meine print-Anweisung spuckt Müllvariablen aus (sie sind jedes Mal anders, wenn ich das Programm aufrufe). Irgendwelche Ideen?

Wenn Sie über Zeiger nachdenken, ist es hilfreich, Diagramme zu zeichnen . Ein Zeiger ist ein Pfeil, der auf eine Adresse im Speicher zeigt, wobei eine Beschriftung den Typ des Werts angibt. Die Adresse gibt an, wo gesucht werden soll, und der Typ gibt an, was zu nehmen ist. Durch Umsetzen des Zeigers wird die Beschriftung des Pfeils geändert, jedoch nicht die Stelle, an der der Pfeil zeigt.

din mainist ein Zeiger cvom Typ char. A charist ein Byte Speicher. Wenn dalso dereferenziert wird, erhalten Sie den Wert in diesem einen Byte Speicher. In der folgenden Abbildung repräsentiert jede Zelle ein Byte.

-+----+----+----+----+----+----+-
 |    | c  |    |    |    |    | 
-+----+----+----+----+----+----+-
       ^~~~
       | char
       d

Wenn Sie dzu int*besetzen, sagen Sie, dass dies dwirklich auf einen intWert hinweist . Auf den meisten heutigen Systemen intbelegt ein 4 Bytes.

-+----+----+----+----+----+----+-
 |    | c  | ?₁ | ?₂ | ?₃ |    | 
-+----+----+----+----+----+----+-
       ^~~~~~~~~~~~~~~~~~~
       | int
       (int*)d

Wenn Sie dereferenzieren (int*)d, erhalten Sie einen Wert, der aus diesen vier Speicherbytes bestimmt wird. Der Wert, den Sie erhalten, hängt davon ab, was in diesen Zellen markiert ?ist und wie ein intim Speicher dargestellt wird.

Ein PC ist Little-Endian , was bedeutet, dass der Wert von a auf intdiese Weise berechnet wird (vorausgesetzt, er umfasst 4 Bytes) : * ((int*)d) == c + ?₁ * 2⁸ + ?₂ * 2¹⁶ + ?₃ * 2²⁴. Wenn Sie also hexadezimal ( printf("%x\n", *n)) drucken , werden die letzten beiden Ziffern immer angezeigt 35(das ist der Wert des Zeichens '5') , während der Wert Müll ist .

Einige andere Systeme sind Big-Endian-Systeme und ordnen die Bytes in die andere Richtung : * ((int*)d) == c * 2²⁴ + ?₁ * 2¹⁶ + ?₂ * 2⁸ + ?₃. Auf diesen Systemen beginnt der Wert immer mit 35hexadezimalem Druck. Einige Systeme haben eine Größe int, die sich von 4 Bytes unterscheidet. Einige wenige Systeme sind intunterschiedlich angeordnet, aber es ist äußerst unwahrscheinlich, dass Sie ihnen begegnen.

Abhängig von Ihrem Compiler und Betriebssystem stellen Sie möglicherweise fest, dass der Wert bei jedem Ausführen des Programms unterschiedlich ist oder dass er immer gleich ist, sich jedoch ändert, wenn Sie den Quellcode auch nur geringfügig ändern.

Auf einigen Systemen muss ein intWert in einer Adresse gespeichert werden, die ein Vielfaches von 4 (oder 2 oder 8) ist. Dies wird als Ausrichtungsanforderung bezeichnet . Je nachdem, ob die Adresse von crichtig ausgerichtet ist oder nicht, kann das Programm abstürzen.

Im Gegensatz zu Ihrem Programm geschieht Folgendes, wenn Sie einen intWert haben und einen Zeiger darauf nehmen.

int x = 42;
int *p = &x;

-+----+----+----+----+----+----+-
 |    |         x         |    | 
-+----+----+----+----+----+----+-
       ^~~~~~~~~~~~~~~~~~~
       | int
       p

Der Zeiger pzeigt auf einen intWert. Das Etikett auf dem Pfeil beschreibt korrekt, was sich in der Speicherzelle befindet, sodass beim Dereferenzieren keine Überraschungen auftreten.

char c = '5'

Ein char(1 Byte) wird auf dem Stapel an der Adresse zugewiesen 0x12345678.

char *d = &c;

Sie erhalten die Adresse von cund speichern sie in d, also d = 0x12345678.

int *e = (int*)d;

Sie zwingen den Compiler anzunehmen, dass 0x12345678er auf ein zeigt int, aber ein int ist nicht nur ein Byte ( sizeof(char) != sizeof(int)). Es können 4 oder 8 Bytes sein, je nach Architektur oder sogar anderen Werten.

Wenn Sie also den Wert des Zeigers drucken, wird die Ganzzahl berücksichtigt, indem das erste Byte (das war c) und andere aufeinanderfolgende Bytes, die sich auf dem Stapel befinden und nur Müll für Ihre Absicht sind, verwendet werden.

Das Casting von Zeigern ist in C normalerweise ungültig. Es gibt mehrere Gründe:

1. Ausrichtung. Es ist möglich, dass der Zielzeigertyp aufgrund von Überlegungen zur Ausrichtung den Wert des Quellzeigertyps nicht darstellen kann. Wenn beispielsweise von int *Natur aus 4 Byte ausgerichtet wären char *, int *würde das Casting in die unteren Bits verlieren.

2. Aliasing. Im Allgemeinen ist der Zugriff auf ein Objekt verboten, außer über einen Wert des richtigen Typs für das Objekt. Es gibt einige Ausnahmen, aber wenn Sie sie nicht sehr gut verstehen, möchten Sie es nicht tun. Beachten Sie, dass Aliasing nur dann ein Problem darstellt, wenn Sie den Zeiger tatsächlich dereferenzieren (wenden Sie die Operatoren *oder ->auf ihn an oder übergeben Sie ihn an eine Funktion, die ihn dereferenziert).

Die wichtigsten bemerkenswerten Fälle, in denen das Casting von Zeigern in Ordnung ist, sind:

1. Wenn der Zielzeigertyp auf den Zeichentyp zeigt. Zeiger auf Zeichentypen können garantiert jeden Zeiger auf einen beliebigen Typ darstellen und ihn auf Wunsch erfolgreich auf den ursprünglichen Typ zurückführen. Der Zeiger auf void ( void *) ist genau das Gleiche wie ein Zeiger auf einen Zeichentyp, außer dass Sie ihn nicht dereferenzieren oder arithmetisch bearbeiten dürfen, und er konvertiert automatisch zu und von anderen Zeigertypen, ohne dass eine Umwandlung erforderlich ist, also Zeiger auf void sind für diesen Zweck normalerweise Zeigern auf Zeichentypen vorzuziehen.

2. Wenn der Zielzeigertyp ein Zeiger auf den Strukturtyp ist, dessen Elemente genau mit den ursprünglichen Elementen des ursprünglich angegebenen Strukturtyps übereinstimmen. Dies ist nützlich für verschiedene objektorientierte Programmiertechniken in C.

Einige andere dunkle Fälle sind in Bezug auf die Sprachanforderungen technisch in Ordnung, aber problematisch und werden am besten vermieden.

Ich vermute, Sie brauchen eine allgemeinere Antwort:

Es gibt keine Regeln für das Wirken von Zeigern in C! Mit der Sprache können Sie jeden Zeiger kommentarlos auf einen anderen Zeiger umwandeln.

Aber die Sache ist: Es gibt keine Datenkonvertierung oder was auch immer getan! Es liegt allein in Ihrer Verantwortung, dass das System die Daten nach der Umwandlung nicht falsch interpretiert - was im Allgemeinen der Fall ist und zu Laufzeitfehlern führt.

Wenn Sie also das Casting durchführen, liegt es ganz bei Ihnen, darauf zu achten, dass die Daten kompatibel sind, wenn Daten von einem gegossenen Zeiger verwendet werden!

C ist für die Leistung optimiert, daher fehlt die Laufzeitreflexivität von Zeigern / Referenzen. Aber das hat seinen Preis - Sie als Programmierer müssen sich besser darum kümmern, was Sie tun. Sie müssen selbst wissen, ob das, was Sie tun möchten, "legal" ist.

Sie haben einen Zeiger auf a char. Wie Ihr System weiß, befindet sich auf dieser Speicheradresse ein charWert für den sizeof(char)Speicherplatz. Wenn Sie es umwandeln int*, arbeiten Sie mit Daten von sizeof(int), sodass Sie Ihr Zeichen und etwas Speichermüll danach als Ganzzahl drucken.