Buna tuturor.As avea nevoie si eu de o lamurire,deoarece am fost luna trecuta la un interviu la o multinationala iar unul din subiectele de la testul tehnic a fost :
int *p=(int* )0x1001;
p++;
Ce valoare are p?
0x1010
0x1003
0x1002
0x1001
Eu am compilat cu Codeblocks si nu imi da nici una din variante, ci 1005
Pe serverul meu imi da 0x1002
Cred ca depinde si de arhitectura si so-ul pe care rulezi programul
#include <stdio.h>
int main()
{
printf("Hello World");
int p=(int )0x1001;
p++;
printf("%p", p);
return 0;
}
daca pun %d imi da 4098
Banuiesc ca ai vrut sa scrii int* p=(int* )0x1001;
Pointerul cand il incrementezi se incrementeaza sa tinteasca spre urmatorul element. Daca int-ul are dimensiunea 4 (poate fi si 2 pe unele sisteme), atunci se aduna 4.
da aia am vrut sa scriu dar nu mi-a luat *
#include <stdio.h>
int main()
{
int *p=(int* )0x1001;
p++;
printf("%x",p);
return 0;
}
asta este codul, si imi afiseaza 1005
Daca este cum a spus @Dani atunci trebuia sa intrebi mai multe informatii despre platforma/compiler etc. Mai exact ce rezulta din sizeof(int). Daca presupui ca sizeof(int) == 4 este 0x1005. Doar daca sizeof(int) == 2 atunci 0x1003. Aici deja trebuie sa ma intreb cat de veche sau limitata este platforma respectiva.
Daca intradevar ai pus codul corect atunci raspunsul este 0x1002. Pentru ca 0x1001 este defapt un numar intreg dar cu notatie hexadecimala.
int p=(int )0x1001; este egal cu int p=4097; pentru compiler. Defapt (int) este inutil in contextul asta.
Un numar hexadecimal (literal) nu reprezinta neaparat un pointer in c/c++. Este doar o altfel de notatie pentru numere intregi (sau nu?). Nu neaparat adrese in memorie (tot aia). La fel si pentru notatia octala. De multe ori de ajuta sa intelegi mai bine codul. Exemplu bun este notatia binara de mai jos in cazul in care folosesti bit-flags sau ceva de genul.
Acelasi rezultat indiferent de notatie:
int b=4097; //dec
int a=0x1001; //hex
int c=010001; //oct
Acest lucru devine mult mai evident in c++14 unde ai mai multa flexibilitate:
int a=0x1001; //hex
int b=4097; //dec
int c=4'097; //pretty dec
int d=010001; //oct
int e=01'0001; //pretty oct
int f=0b0001000000000001; //bin
int g=0b0001'0000'0000'0001; //pretty bin
Toate devin acelasi lucru eventual. Este pur si simplu o notatie diferita. Cum se zice “syntax sugar”?
Si daca era sa fie pointer. Toate sunt valide. Pentru ca nu il intereseaza pe compiler ce notatie folosesti cat timp este in limitele tipului fundamental pe care il folosesti (int in cazul asta. sau uintptr_t daca e pointer)
Din nou. Toate fac acelasi lucru:
int *a=(int *)(0x1001); //hex
int *b=(int *)(4097); //dec
int *c=(int *)(4'097); //pretty dec
int *d=(int *)(010001); //oct
int *e=(int *)(01'0001); //pretty oct
int *f=(int *)(0b0001000000000001); //bin
int *g=(int *)(0b0001'0000'0000'0001); //pretty bin
Spre sfarsit am cam amestecat cu c++ putin. Insa te ajuta sa intelegi mai bine ca nu il intereseaza pe compiler ce notatie folosesti atata timp cat conversia este definita si nu se pierd informatii.
Parerea mea este ca era un fel de intrebare capcana. Sa vada ce crezi ca este p. Un pointer catre un int sau doar un int. Ba chiar si numele p este dat la deruta. Asta in cazul in care este corect ce ai scris tu.
Amuzanta intrebarea oricum 
Echivalentul lui 0x1001 din hexadecimal in decimal (adica int) este 4097.
Se face incrementare cu 1, devine 4098. Variantele de raspuns sunt in hexa, deci convertesti 4098 in hexa, si o sa iti dea 0x1002 raspunsul.
Problema e ca el are un pointer (for some reason, se pierd * in code example-urile de mai sus), deci in momentul in care face +1, de fapt se adauga sizeof(int), pentru ca de fapt compilerul/limbajul de programare se asteapta ca vrei sa iei urmatorul element de acelasi tip din memorie (eg. cand parcurgi un array).
Deci, daca ai int *p = (int *) 0x1001, ii spui compilerului ca tu ai un pointer catre un element de tip int care se gaseste la adresa 0x1001 in memorie (doar ca in acest caz il folosesti direct ca valoare, ignorand ce este stocat la adresa respectiva, adica fara sa ii mai faci dereference). In momentul in care faci +1 pe pointer, se va face +sizeof(int), de acolo si noua valoare fiind 0x1005. Singurul raspuns alternativ valid din exemplu, e 0x1003, atunci cand sizeof(int) = 2, adica pe un CPU 16-bit (microprocesoare maybe?)