Om *pc är en pekare så vad är pc utan stjärna?

*pc är inte en pekare.

int* pc, c;

är ekvivalent med

int* pc;
int c;

och deklarerar alltså pc som en pekare till int, och c som en int. *pc är värdet som pc pekar på, och pc är själva pekaren.

Hmmmm läste nyss om att int *pc är pekaren och pc är adressen till pekaren.

I am Me skrev:

int* pc, c;
c = 5;
pc = &c;
*pc = 1;
printf("%d", *pc); // Ouptut: 1
printf("%d", c); // Output: 1

pc är själva pekaren

när du deklarerar en pekare använder du * för att visa detta

// en pekare pc blir deklarerad
int* pc == NULL;

// en heltalsvariabel c blir deklarerad
int c = 0;

// nu får pekaren pc samma adress där c ligger i minnet.
pc = &c;

// nu tilldelar du 1 till c
*pc = 1;

Bara tillägger: pekaren innehåller (har värdet) adressen till nånting, det som den pekar på.

pc har själv en adress i minnet. Om du vill ha den skriver du &pc.

anders_k skrev:

I am Me skrev:

int* pc, c;
c = 5;
pc = &c;
*pc = 1;
printf("%d", *pc); // Ouptut: 1
printf("%d", c); // Output: 1

pc är själva pekaren

när du deklarerar en pekare använder du * för att visa detta

// en pekare pc blir deklarerad
int* pc == NULL;

// en heltalsvariabel c blir deklarerad
int c = 0;

// nu får pekaren pc samma adress där c ligger i minnet.
pc = &c;

// nu tilldelar du 1 till c
*pc = 1;

Varför skrev du 

int* pc == NULL;  ? 

I am Me skrev:

// en pekare pc blir deklarerad
int* pc == NULL;

// en heltalsvariabel c blir deklarerad
int c = 0;

// nu får pekaren pc samma adress där c ligger i minnet.
pc = &c;

// nu tilldelar du 1 till c
*pc = 1;

Varför skrev du 

int* pc == NULL;  ? 

En bra tumregel är att man alltid initialiserar alla sina variabler innan man använder dom.

På så vis kan verkligen vara säker på om något fungerat eller inte fungerat.

När man hållit på länge och programmera gör man det automatiskt, det är det jag gjort.

anders_k skrev:

I am Me skrev:

int* pc, c;
c = 5;
pc = &c;
*pc = 1;
printf("%d", *pc); // Ouptut: 1
printf("%d", c); // Output: 1

pc är själva pekaren

när du deklarerar en pekare använder du * för att visa detta

// en pekare pc blir deklarerad
int* pc == NULL;

// en heltalsvariabel c blir deklarerad
int c = 0;

// nu får pekaren pc samma adress där c ligger i minnet.
pc = &c;

// nu tilldelar du 1 till c
*pc = 1;

Hahah är fortfarande inte säkert om pekarna. 

När något deklareras så det skapas en plats i minnet för den. Så det betyder att även pekaren pc har en plats i datorns minne. Om jag förstår rätt *pc har med sig ett värde och pc har med sig adressen. När pc och c har samma adress samt *pc pekar på värdet 1 då har även c värdet 1? 

Så här kan det se ut. Till vänster står minnesadresser och efter kolon står värdet som ligger där.

100: 0

101: 0

På adress 100 har kompilatorn lagt pc, och på 101 ligger c. De har nåt obestämt värde från början, men jag skrev 0 där.

c = 5 görs, och nu har vi 

100: 0

101: 5

Så gör vi pc = &c och får 

100: 101

101: 5

Sist gör vi *pc = 1 och då blir det 

100: 101

101: 1

Tack för era svar 🌷

I am Me skrev:

Hahah är fortfarande inte säkert om pekarna. 

När något deklareras så det skapas en plats i minnet för den. Så det betyder att även pekaren pc har en plats i datorns minne. Om jag förstår rätt *pc har med sig ett värde och pc har med sig adressen. När pc och c har samma adress samt *pc pekar på värdet 1 då har även c värdet 1? 

Ja en pekare tar också en plats i minnet, så

int* pc; 

deklarerar en variabel i minnet (t.ex. stacken) som inte pekar någonstans, men du kan få fram adressen av pekaren själv genom

&pc

du kan se själva adressen genom skriva ut den

printf("%p", &pc);

så om du deklarerar två variabler

int c;
int* pc; 

och skriver ut dem

printf("%p %p\n", &c, &pc);

kan du se adresserna av dem  du ser då att de ligger efter varandra i minnet.

"pc" kan du sedan tilldela "c's" adress

pc = &c

 vilket är samma sak som att pc pekar på c

så var tror du följande skriver ut nu?

printf("%p\n", pc);