- объявление указателя
Идентификатор типа данных *имя переменной-указателя Пример: int *p_ipoint;//Объявить целочисленный указатель
- назначение указателя
Первый метод присваивания присваивает значение во время инициализации
int i=100; int *p=&I;
Второй метод присвоения назначается на более позднем этапе
int i=100; int *p; p=&I;
Объяснение: Доступ к переменной через имя переменной является прямым, а доступ к переменной через указатель — косвенным.
- Примечание об использовании указателя.
Имя переменной-указателя p, а не *p, p=&i означает взять адрес переменной i и присвоить его переменной-указателю p. пример:
#include <iostream>
int main()
{
int i = 100;
int *p = &i;
printf("%d\n",p);
}
Переменные-указатели не могут быть назначены напрямую. пример:
int i = 100;
int *p;
p = 100;
Компиляция не удалась, ошибка следующая:
int *p;
p = (int*)100;//Присвоить 100 указателю переменной путем принудительного принуждения.
printf("%d", p);//Вывод адреса, можно выводить адрес
printf("%d", *p);//Вывод значения, на которое указывает указатель, сообщение об ошибке
*p нельзя использовать как переменную. пример:
int *p;
*p =100;//Указатель не получает адрес.
printf("%d", p);//Выходной адрес, сообщение об ошибке
printf("%d", *p);//Вывод значения, на которое указывает указатель, сообщение об ошибке
- оператор указателя и оператор адреса
* — оператор указателя, & — оператор адреса.
Объявление и инициализация переменной-указателя использует операторы * и &. пример:
int *p=&a;
Это утверждение эквивалентно следующему утверждению:
int *(p=&a);
Если он будет записан как *p=&a, программа сообщит об ошибке.
Р в &*p может быть только указателем, если перед именем переменной поставить *, то при компиляции произойдет логическая ошибка.
Примечание: разница между &*p и *&a.
Операторы & и * имеют одинаковый приоритет и комбинируются в направлении справа налево, поэтому оператор &*p сначала выполняет операцию *, а *p эквивалентен переменной a, а затем выполняет операцию &, и &*p эквивалентно получению переменной a адреса. *&a должен сначала вычислить оператор &, &a взять адрес переменной a, а затем вычислить операцию *, *&a эквивалентно значению адреса переменной a, которая на самом деле является переменной a.
- указатель на нуль и указатель на нулевой тип
Указатель может указывать на данные любого типа, включая void:
void* p; //Определяем переменную-указатель на нулевой тип.
Нулевой указатель может принимать данные любого типа, и когда он используется, его можно привести к соответствующему типу данных. пример:
#include <iostream>
using namespace std;
int main()
{
int *pl = NULL;
int i = 4;
pl = &i;
float f = 3.333f;
bool b = true;
void *pV = NULL;
cout
pV = pl;
cout << "pV=pl------" << (int*)pV << endl;
cout
pV = &f;
cout << "pV=&f--------" << *(float*)pV << endl;
cout
return 0;
}
- указатель на константу и указатель на константу,
Как и другие типы данных, указатели также имеют константы, использующие ключевое слово const в следующей форме:
int i=9;
int* const p=&i;
*p=3;
Ключевое слово const ставится перед идентификатором, указывая на то, что сами данные являются константой, а тип данных — int*, то есть целочисленный указатель. Как и его константы, константы указателя должны быть инициализированы. Мы не можем изменить память, на которую он указывает, но мы можем изменить содержимое памяти, на которую он указывает.
Если ключевое слово const помещается перед типом указателя, форма выглядит следующим образом:
int i=9;
int const* p=&i;
Это указатель на константу.Хотя данные, на которые он указывает, могут быть изменены с помощью операторов присваивания, операция изменения содержимого памяти с помощью этого указателя не разрешена.
Когда const используется в следующей форме:
int i=9;
int const* const p=&i;
Указатель является константой указателя на константу. Он не может ни изменить свое указание памяти, ни изменить содержимое указанной памяти.
пример:
#include <iostream>
using namespace std;
int main()
{
int i = 5;
const int c = 99;
const int* pR = &i;//Этот указатель можно использовать только для "чтения" данных памяти, но он может изменять свой собственный адрес.
int* const pC = &i;//Сам этот указатель является константой, он не может изменить указатель, но может изменить содержимое памяти.
const int* const pCR = &i;//Этот указатель может использоваться только для «чтения» данных памяти и не может изменить указатель
cout
cout
cout
i = 100;
cout << "i:" << endl;
cout
pR = &c;
cout << "*pR:" << endl;
cout
cout
*pC = 6;
cout << "i:" << i << endl;
cout
//pCR=&c; //ошибка
//*pCR=100;//Отчет об ошибках
cout
return 0;
}