Bästa svaret
(int *) p är en uttrycklig typgjutning för värdet som lagras i variabeln p, till typen av en pekare vars adress pekar på ett heltal. Värdet som p lagrar är en minnesadress för den första byten av de 4 som används för att lagra nämnda 32-bitars (4 byte) heltal.
En pekare lagrar ett tal som bör vara adressen till en specifik plats i minnet (Heap eller Stack). Typen av data som lagras på den platsen kan vara vad som helst , och i detta uttryck anger vi (eller snarare antar) att det är ett 4-byte-heltal.
Värdet på p kan skrivas innan det tilldelas en annan pekare –
int *c = (int *) p;
Eller det kan hänvisas till att hämta värdet som sparats i adressen som p innehöll som så –
int c = *((int *) p);
Eller, om p verkligen är en pekare i sig kan den hänvisas utan den uttryckligen typprognostiserat eftersom vi vet att värdet som är lagrat i det är ett 4-byte heltal.
För enkelhetens skull har jag inte nollkontrollerat pekarna. Det är viktigast att du kontrollerar om en pekare är noll eftersom om du hänvisar till en nollpekare resulterar i en krasch.
Exempel på en noll check –
if (p != null)
printf(“int is ‘\%d’”, *p);
Antar nu att adressen är korrekt och att pekaren inte är null, och att datatypen som är lagrad på minnesplatsen faktiskt är ett heltal, kommer din konsol att skriva ut den korrekt .
Här är en detaljerad och väl förklarad artikel som jag stötte på för några år sedan, om hur man läser pekare i c – Medurs / Spiralregel
Svar
För att förstå vad det (int *) gör där, är det bra att förstå vad malloc (sizeof (int)) gör. Låt ”bryter ner det från höger till vänster.
Först har vi en storlek på (int). Detta är ett värde som representerar antalet byte som krävs för att representera ett heltal i minnet. Detta kan vara 4 eller något annat nummer beroende på vilken dator vi programmerar på.
Så malloc () -funktionen får faktiskt en parameter som 4, a la malloc (4). Denna funktion frågar C-bibliotek för att gå någonstans i minnet och avsätta 4 byte (som råkar vara exakt rätt storlek för att innehålla ett heltal).
Nu returnerar malloc-funktionen alltid adressen till minnet. minne läggs ut seriellt och varje adress i minnet är unik. Nu är malloc () inte en mycket smart funktion – du berättar hur mycket minne du vill ha och det står ”här är det”. Det vet inte vad du vill lägga in det minnet – det vet bara hur mycket minne du bad om.
Eftersom malloc () inte vet vad du vill lägga in det minnet, returnerar den en typ som heter (ogiltig *), det vill säga en godtycklig minnesadress, annars känd som en pekare. På de flesta moderna datorer är en adress ett 64-bitars värde som kan representeras i 8 byte minne – men datorer skiljer sig åt r, och olika datorer kan returnera olika storlekar. Så malloc () kan returnera 8 byte data i (ogiltigt *) format.
Slutligen måste vi komma in i det minne som malloc () gav oss, så att vi kan behandla det som innehåller en heltal. Hur gör vi det? malloc () gav oss bara en pekare till lite minne ute i rymden någonstans. Vi gör det genom att berätta för kompilatorn att minnesadressen vi fick tillbaka från malloc () verkligen är adressen till ett heltal. Hence your (int *).
Nu har du gått igenom allt detta, kompilatorn förstår sedan fullständigt vad du ville, för du har gjort dig besväret att beskriva varje steg: du vill ha en åtta-byte adress som pekar på en plats med fyra byte i minnet, som i sin tur innehåller ett heltal.
Och det är vad hela uttrycket betyder!