Was passiert eigentlich, wenn ein Zeiger auf integer gecastet wird, um einen Zeiger auf char?

int i=40;
char *p;
p=(char *)&i;//What actually happens here?
printf("%d",*p);

Was wird der Ausgang? Bitte um Hilfe!!

Der Titel deiner Frage spricht über Umwandlung eines integer in ein char-Zeiger, aber das ist nicht das, was Ihr code tut. Es ist ein casting int Zeiger auf einen char Zeiger.

InformationsquelleAutor vas | 2010-09-20

  1. 7
    p=(char *)&i;//What actually happens here?

    Nimmt es die Adresse von i und wirft es zu einer char Zeiger. Also der Wert von *p ist jetzt das erste byte der i. Was das Wert ist, ist Plattform abhängig.

    Wahrscheinlich wäre entweder 0 oder 40 (je nach endianness der Maschine).
    Warum ist cast erforderlich , was ist der Unterschied zwischen char *p = (char *) &i und char *p = &i ?

    InformationsquelleAutor sepp2k

  2. 5

    Beginnen wir, indem wir schauen, wie der Inhalt i und p wäre im Speicher angeordnet (vorausgesetzt, big-endian-Reihenfolge):

    Element Adresse 0x00 0x01 0x02 0x03 
---- ------- ---------------------- 
ich 0x08000000 0x00 0x00 0x00 0x28 
p 0x08000004 0x?? 0x?? 0x?? 0x??

    Seit p wird erklärt, wie eine auto-variable nicht initialisiert zu nichts und enthält ein zufälliges bit-Muster, vertreten durch 0x??.

    In der Zeile

    p = (char *)&i;

    den Ausdruck &i wertet die Adresse von i oder 0x08000000, und sein Typ ist pointer to int oder int *. Der cast wandelt den Typ aus int * zu char *, und das Ergebnis zugewiesen wird, um p.

    Hier ist, wie Dinge Aussehen im Speicher nach der Zuordnung:

    Element Adresse 0x00 0x01 0x02 0x03 
---- ------- ---------------------- 
ich 0x08000000 0x00 0x00 0x00 0x28 
p 0x08000004 0x08 0x00 0x00 0x00

    Also der Wert von p ist jetzt die Adresse von i. In der Zeile

    printf("%d", *p);

    den Typ des Ausdrucks *p ist char, und sein Wert ist unabhängig gespeichert in Adresse 0x08000000, die in diesem Fall 0 ist. Da printf ist eine Variable Funktion, die den Wert *p wird gefördert vom Typ char zu geben int.

    Also für diesen speziellen Fall, der Ausgang ist "0". Wenn die Reihenfolge little-endian, die Karte würde wie folgt Aussehen

    Element Adresse 0x03 0x02 0x01 0x00 
---- ------- ---------------------- 
ich 0x08000000 0x00 0x00 0x00 0x28 
p 0x08000004 0x08 0x00 0x00 0x00

    und die Ausgabe "40".

    Beachten Sie, dass dieses ganze Beispiel wird davon ausgegangen, dass integer-und character-Zeiger haben die gleiche Größe und layout; das ist nicht garantiert, um wahr zu sein, überall (siehe die Online-C-Standard (n1256 Entwurf), Abschnitt 6.2.5, Absatz 27), so können Sie sich nicht darauf verlassen, dass diese arbeiten von überall die Art und Weise, die Sie erwarten (vorausgesetzt, dass ich richtig bin in der Annahme, dass int und char sind nicht-kompatible Typen, definiert durch den standard, aber ich könnte falsch sein). Typ Zweideutigkeiten im Allgemeinen ist das sicher nicht.

    Ihre Beschreibung wird davon ausgegangen, dass int* und char* Zeiger haben die gleiche Größe und layout, aber auch das sichtbare Verhalten des Programms nicht. Der C-Standard garantiert, dass alle Objekte zugegriffen werden kann wie ein array von Zeichen, also den OP-code wird der Zugang der ersten (untersten angesprochen) byte i. Der Wert der byte, wie andere haben darauf hingewiesen -, hängt von der Implementierung.
    Warum ist cast erforderlich , was ist der Unterschied zwischen char *p = (char *) &i und char *p = &i ?
    Warum ist cast erforderlich , was ist der Unterschied zwischen char *p = (char *) &i und char *p = &i ?
    Der Unterschied ist, dass char *p = (char *) &i;islegal, und char *p = &i;ist nicht. Es gibt keine implizite Konvertierung zwischen char* und int* (obwohl einige Compiler erlauben es, vorzugsweise mit einer Warnung). Zeiger Konvertierungen können gefährlich sein, lassen Sie behandeln Sie ein Objekt des Typs als wäre es eine andere Art, damit die Sprache erfordert eine solche Konvertierungen explizite.
    Wenn der compiler erlaubt es, mit einem waring , wie "Initialisierung von inkompatiblen Typ" dann sind Sie gleich , tun, Verhalten Sie sich gleich. Das nervt mich schon sehr lange.

    InformationsquelleAutor John Bode

  3. 2

    hier sind Sie

    int i = 40; //allokierung von Speicher für die Ganzzahl i und die Zuweisung mit dem Wert 40 zu

    char *p = (char*)&i;

    also hier definieren Sie einen Zeiger-variable und Zuweisung der Adresse, die ich nach dem Gießen es auf char*

    angenommen i zugewiesen 1021 address so p wird die Adresse mit der Grenze von 1 byte so sollte es halten first 8 bit from the representation of 40;

    als 40 wurden decken unter die ersten 8 bit 2 byte, es wird halt einen char equivalend 40 aber Sie drucken es mit %d es shopuld drucken 40;

    Außer, dass die Maschine möglicherweise big-endian-in dem Fall erhalten Sie 0.
    Warum ist cast erforderlich , was ist der Unterschied zwischen char *p = (char *) &i und char *p = &i ?

    InformationsquelleAutor Jigar Joshi

  4. 1

    Kommt es an. Unter Windows wird die Ausgabe 40, aber das ist nur, weil eine Menge von Zufällen:

    Zunächst, printf nicht (kann nicht) überprüfen Sie den Typ Ihrer Argumente, also da sieht Sie %d im Formatstring, es wird davon ausgegangen, dass das gegebene argument ist ein int. Obwohl *p ist nur ein char, das Ergebnis wird gefördert, die einen int-Wert (wie für jedes argument, das nicht in der Funktion angegebenen Prototyp).

    Zweite, p-Punkt, um den Speicher genommen, die durch die variable i, aber da es ein char-pointer, es dauert nur ein byte aus dem Speicher des ich. Da Windows/Intel verwendet Least-Significant-Byte zuerst übereinkommen, 40 gespeichert werden als byte-Muster "40 0 0 0" so, da *p nimmt das erste byte (char), das Ergebnis wird sein 40. Wenn ich den Wert 256 oder größer, das Ergebnis wäre falsch.

    Sehen Sie hierzu auch Das stackoverflow.com/questions/34826036/...

    InformationsquelleAutor Patrick

  5. 0

    Was passiert, wenn die int-Zeiger ist typecasted char?
    Es ist eine andere Frage markiert, dupliziert, hier, ich versuche zu erklären.

    $ cat a.c
#include <stdio.h>

int main(){
    int a;
    char *x;
    x = (char *) &a;
    a=512;
    x[0]=1;
    x[1]=2;
    printf("%d\n",a);
    return 0;
}

    Kompilieren und ausführen:

    $ gcc a.c && ./a.out
513

    Warum es 513? Wir können verwenden Sie gdb, um zu sehen, die Ursache.

    $ gcc a.c -g && gdb ./a.out
(gdb) list
1       #include <stdio.h>
2
3        int main(){
4            int a;
5            char *x;
6            x = (char *) &a;
7            a=512;
8            x[0]=1;
9            x[1]=2;
10           printf("%d\n",a);

    legen Sie einen Haltepunkt in Zeile 8 ein.c, und führen Sie

    (gdb) b a.c:8
Breakpoint 1 at 0x40113d: file a.c, line 8.
(gdb) run

    einmal Programm stop auf break point, print-variable, die eine Speicheradresse.

    (gdb) p &a
$2 = (int *) 0x7fffffffd9d4
(gdb) p x
$3 = 0x7fffffffd9d4 ""

    variable, die eine Speicheradresse ist 0x7fffffffd9d4, und die variable x der Wert ist der gleiche.

    vor der show memory content, lassen Sie uns wissen, wie 512 im hex-format, es ist:

    00 00 02 00

    - und x86 ist little-endian, also im Speicher sollte es sein:

    [higher address] 00 02 00 00 [lower address]

    let ' s show der tatsächliche Speicher, nur als gleiche, als wir dachten.

    (gdb) x/4xb 0x7fffffffd9d4
0x7fffffffd9d4: 0x00    0x02    0x00    0x00

    dann zeigen Speicheradresse von x[0] und x[1], und konvertieren Sie den Speicher Inhalt zu real-Wert, sollte es nicht schwer zu verstehen, warum drucken Sie 513.

    (gdb) p &x[0]
$4 = 0x7fffffffd9d4 ""
(gdb) p &x[1]
$5 = 0x7fffffffd9d5 "\002"

    InformationsquelleAutor L. Ouyang

Schreibe einen Kommentar