Присвоение значений указателю

В вашем примере это ошибка компилятора.

Однако я предполагаю, что вы хотели сделать следующее:

int n =23, *p;
p = &n;
//Change the value of p to 3000, p now points to address 3000
p = reinterpret_cast<int*>(3000); 
//Check if the address of n has changed
std::cout << "Address of n : " << reinterpret_cast<int>(&n) << std::endl; 

Как вы можете сказать, когда вы запускаете этот код. Адрес не меняется.

По вашему второму вопросу.

И да и нет :)

Если вы определяете две переменные рядом друг с другом, они могут быть рядом друг с другом в памяти.

 int a,b,c,d;
 char c = 1;
 short s = 1;
 void* p = nullptr;
 int i = 1;

 std::cout << "a is at: " << reinterpret_cast<int>(&a) << std::endl;
 std::cout << "b is at: " << reinterpret_cast<int>(&b) << std::endl;
 std::cout << "c is at: " << reinterpret_cast<int>(&c) << std::endl;
 std::cout << "d is at: " << reinterpret_cast<int>(&d) << std::endl;
 std::cout << "Char is at: " << reinterpret_cast<int>(&c) << std::endl;
 std::cout << "Short is at: " << reinterpret_cast<int>(&s) << std::endl;
 std::cout << "Pointer is at: " << reinterpret_cast<int>(p) << std::endl;
 std::cout << "Int is at: " << reinterpret_cast<int>(&i) << std::endl;

Такое поведение вызвано компилятором, определяющим, куда все втыкать. Они могут или не могут существовать рядом друг с другом. Если вы хотите гарантировать, что они существуют рядом друг с другом, используйте массив.

int arr[] = {1,2,3,4,5,6,7};
int * p = &arr[0]; //get address of first element
for(int i = 0 ; i < 7; ++i)
    std::cout << "Value at address: " << reinterpret_cast<int>(p+i) 
        << " is: " << *( p + i) << std::endl;

Предполагая, что вы скомпилируете его, добавив приведение

p=(int *)5;

Тогда разыменование этого указателя будет неопределенным поведением. Он может делать что угодно, но, скорее всего, ваша программа прервется. В разных системах он может вести себя по-разному.

Кроме того, какой адрес получает переменная или следующая, также зависит от системы, в которой вы запускаете свою программу. Большинство систем используют стек для локальных переменных, но они могут считать вверх или вниз, так что вы не знаете.

Сборки отладки и оптимизации также могут создавать разный код. Некоторые компиляторы оставляют место после локальных массивов или переменных, поэтому они могут выдавать осмысленную ошибку, когда вы пишете вне массива. Но в релизе они могут использовать память как можно плотнее.

Чтобы сделать ситуацию еще более непредсказуемой, основные операционные системы имеют метод, называемый рандомизацией адресного пространства (ASLR).

https://en.wikipedia.org/wiki/Address_space_layout_randomization

Базовый адрес, который получают переменные, будет рандомизирован при каждом запуске программы. таким образом хакеры больше не могут злоупотреблять переполнением буфера и вычислять адреса возврата там, где они внедряют свой собственный код.

Так что нет, вы не можете сказать ничего общего об адресах переменных. Вы должны проверить свой компилятор и операционную систему.

Вы можете привести int к указателю. Это стандарт. И стандарт гарантирует, что если вы вернете указатель обратно к int, вы должны получить исходное значение, при условии, что между ними не произошло усечения.

Но разыменование такого указателя является Undefined Behavior. Это означает, что в обычной реализации вы либо получите ошибку сегмента или нарушение памяти, если попытаетесь прочитать неотображенный адрес или адрес только для записи, либо просто получите непредсказуемое значение, потому что вы читаете в месте, которое вы не знаете, что там лежит. .

И еще хуже, если вы пишете туда, потому что вы можете перезаписать случайное место в вашей программе. Только представьте, что может произойти, если вы перезапишете адрес возврата из функции...

Единственный реальный вариант использования для этого - это когда некоторые специальные аппаратные регистры отображаются на хорошо известные адреса. Тогда вы действительно пишете:

char *p;
p = 0x60;    // say 0x60 is the address of a special register you want to read
char reg_value = *p;

Это не может быть определено стандартом, потому что стандарт не делает предположений о базовой платформе, а является локальным расширением, которое должно быть задокументировано для конкретной аппаратной платформы.

Возьмем аналогию....

int  x = 3;
int* x_p = &x;

Вы можете видеть это так: теперь у вас есть лист бумаги с именем x, на котором написано число 3. И у вас есть еще один лист бумаги, на котором написано местоположение первого листа бумаги. Как это делается в деталях, на самом деле не имеет значения, поэтому предположим, что второй лист бумаги называется x_p и на нем написано x. В этом плане

int y = *x_p;

означает: посмотрите на бумагу x_p, интерпретируйте это как расположение другого листа бумаги и возьмите значение, написанное на этом листе, то есть y будет иметь значение 3.

Что произойдет, если вы напишете что-то еще на бумаге x_p? Во-первых, если вы все-таки попытаетесь интерпретировать его как местонахождение другой бумажки, у вас ничего не получится, либо вы просто получите случайную бумажку, но не ту, которую искали. Во-вторых, как это повлияет на первый лист бумаги x? Это никак не влияет на это. Указатели — это такие же переменные, как и любые другие, просто вы обычно интерпретируете их значение как местоположение какой-либо другой переменной, но в остальном между указателем и указателем нет никакой связи.

Не лучшая аналогия, но, возможно, это поможет.

Да, вы правы, и это адресный оператор. Он дает указатель, на какой адрес он будет указывать.

Если вы набираете p со звездочкой, это означает, что вы хотите получить значение из этой точки указателя.

Целое число занимает 4 байта из памяти, поэтому каждый раз, когда вы создаете целое число, оно будет занимать 4 байта из стека памяти. Это может быть убывающий или возрастающий порядок.

Вы также можете попробовать все это на своей стороне.

int n = 23,*p;
int n2 = 24;
int n3 = 25;

p = &n;
printf("%d %d %d %d %d",p,n,*p,&n2,&n3);