4.1. Указатели на объекты

Теория

Зачем нужен этот пункт

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

Указатель — это переменная, которая хранит адрес другого объекта в памяти. Через указатель можно обратиться к этому объекту косвенно: прочитать его значение или изменить его.

Указатели нужны для:

В этом пункте рассматриваются только первые основы: адрес переменной, объявление указателя, операция &, операция *, значение NULL и безопасное начальное использование указателей.

Базовые и производные типы

В языке C есть базовые типы данных: char, int, float, double, enum, void и их модификации с short, long, signed, unsigned.

Кроме базовых типов, в C есть производные типы. Они строятся на основе уже существующих типов.

С массивами и функциями мы уже познакомились в главе 2. Теперь нужно отдельно разобраться с указателями.

Переменная: имя, адрес и значение

Каждая переменная в программе занимает участок памяти. У переменной можно выделить три важных свойства:

int number = 10;

В этой строке:

Обычно программист работает с переменной по имени:

printf("%d\n", number);

number = 25;

Но язык C позволяет получить адрес переменной и работать с ней косвенно — через указатель.

Адрес переменной

Адрес — это числовое значение, которое показывает, где в памяти находится объект программы.

Чтобы получить адрес переменной, используется унарная операция &.

&имя_переменной

Например:

int number = 10;

printf("%p\n", (void *)&number);

Здесь выражение &number означает «адрес переменной number».

Для вывода адреса используется спецификатор %p. В современном корректном C при выводе через %p адрес обычно приводят к типу void *.

Операция &

Операция & называется операцией взятия адреса. Она возвращает адрес объекта, который расположен в памяти.

int x = 5;

printf("value = %d\n", x);
printf("address = %p\n", (void *)&x);

Первый вызов printf выводит значение переменной. Второй вызов выводит адрес переменной.

Операцию & можно применять не ко всему подряд. Её применяют к объектам, которые действительно имеют место в памяти.

Правильно:

int x = 10;
int *p = &x;

Неправильно:

int *p;

p = &10;       /* нельзя взять адрес числового литерала */
p = &(x + 1);  /* нельзя взять адрес временного результата выражения */

Что такое указатель

Указатель — это переменная, значением которой является адрес некоторого объекта.

int number = 10;
int *p = &number;

Здесь:

После этого говорят: p указывает на number.

Объявление указателя

Чтобы объявить указатель, нужно указать тип объекта, на который он будет указывать, и поставить символ *.

тип *имя_указателя;

Примеры:

char *pc;
int *pi;
float *pf;
double *pd;

Эти объявления читаются так:

Тип указателя показывает, объект какого типа находится по адресу, который хранится в указателе.

Символ * в объявлении и в выражении

Символ * используется в C в разных смыслах. В объявлении он означает, что объявляется указатель.

int *p;

Эта строка означает: p — указатель на int.

А в выражении *p означает обращение к объекту, на который указывает p.

int x = 10;
int *p = &x;

printf("%d\n", *p);

Здесь *p означает «значение объекта, адрес которого хранится в p».

Разыменование указателя

Операция *, применённая к указателю, называется разыменованием, или косвенной адресацией.

int x = 10;
int *p = &x;

printf("%d\n", *p);

Пошагово:

  1. x — обычная переменная со значением 10;
  2. &x — адрес переменной x;
  3. p хранит этот адрес;
  4. *p обращается к объекту по этому адресу;
  5. поэтому *p даёт значение x.

Если p указывает на x, то чтение *p похоже на чтение x.

Изменение переменной через указатель

Через разыменованный указатель можно не только читать значение, но и изменять его.

#include <stdio.h>

int main(void)
{
    int x = 10;
    int *p = &x;

    printf("x = %d\n", x);

    *p = 25;

    printf("x = %d\n", x);

    return 0;
}

Результат:

x = 10
x = 25

Оператор:

*p = 25;

означает: записать значение 25 в тот объект, на который указывает p. Так как p указывает на x, изменяется именно x.

Один объект — два способа доступа

Если указатель хранит адрес переменной, к одному и тому же участку памяти можно обратиться двумя способами:

int value = 100;
int *p = &value;

value = 200;
*p = 300;

И value = 200;, и *p = 300; изменяют один и тот же объект.

После выполнения всего фрагмента значение value будет равно 300.

Пример: явная работа с адресом при присваивании

Обычный оператор присваивания:

E = B + C;

можно представить как запись результата выражения в участок памяти, связанный с переменной E. С помощью указателя это можно сделать явно.

int E;
int B = 10;
int C = 20;
int *m;

m = &E;
*m = B + C;

Здесь:

Такой пример нужен для понимания механизма. В обычной программе проще написать E = B + C;, но указатели становятся необходимыми в более сложных задачах.

Указатель должен иметь корректное значение

Указатель сам по себе является переменной. Если его объявить, но не присвоить ему адрес, его значение будет неопределённым.

int *p;

*p = 10;  /* опасная ошибка */

Здесь p не указывает на известный объект. Разыменование такого указателя может привести к повреждению памяти или аварийному завершению программы.

Правильно:

int x;
int *p = &x;

*p = 10;

Теперь p указывает на существующую переменную x, поэтому запись через *p корректна.

NULL-указатель

Если указатель пока ни на что не должен указывать, ему можно присвоить специальное значение NULL.

#include <stdio.h>

int *p = NULL;

NULL означает нулевой указатель — специальное значение, которое не является адресом обычного объекта.

Перед разыменованием указатель можно проверить:

if (p != NULL)
{
    printf("%d\n", *p);
}

Важно: NULL нельзя разыменовывать.

int *p = NULL;

printf("%d\n", *p);  /* ошибка */

Инициализация указателя

Хорошая привычка — сразу задавать указателю начальное значение.

int x = 10;
int *p1 = &x;
int *p2 = NULL;

Здесь:

Неинициализированный указатель опасен:

int *p;       /* значение неизвестно */
*p = 5;       /* ошибка */

Тип указателя имеет значение

Указатель связан с типом объекта, на который он указывает.

int x = 10;
double y = 3.14;

int *pi = &x;
double *pd = &y;

pi должен указывать на объект типа int, а pd — на объект типа double.

Тип нужен компилятору, чтобы понимать:

Указатель void *

Особый вид указателя — void *. Такой указатель может хранить адрес объекта любого типа.

int x = 10;
double y = 3.14;

void *p;

p = &x;
p = &y;

Но указатель void * нельзя напрямую разыменовывать, потому что тип void означает отсутствие конкретного типа объекта.

void *p;
int x = 10;

p = &x;

/* printf("%d\n", *p);  нельзя */

Чтобы получить значение, нужно привести указатель к нужному типу:

printf("%d\n", *(int *)p);

На начальном этапе void * достаточно понимать как «обобщённый адрес», который требует аккуратного приведения типа перед использованием.

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

Указателю можно присвоить:

int x = 10;
int y = 20;

int *p;
int *q;

p = &x;
q = p;

p = &y;
q = NULL;

После q = p; оба указателя хранят один и тот же адрес. Это не копирует сам объект, а только копирует адрес.

int x = 10;

int *p = &x;
int *q = p;

*q = 50;

printf("%d\n", x);

После *q = 50; переменная x станет равной 50, потому что p и q указывают на один объект.

Адрес самого указателя

Указатель — это тоже переменная. Значит, у него есть собственный адрес в памяти.

int x = 10;
int *p = &x;

printf("address of x = %p\n", (void *)&x);
printf("value of p   = %p\n", (void *)p);
printf("address of p = %p\n", (void *)&p);

Здесь:

Это разные вещи. p хранит адрес другого объекта, но сам p тоже где-то хранится в памяти.

Указатель на указатель: первое представление

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

int x = 10;
int *p = &x;
int **pp = &p;

Здесь:

printf("%d\n", x);
printf("%d\n", *p);
printf("%d\n", **pp);

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

Звёздочка относится к конкретному имени

При объявлении нескольких переменных в одной строке важно помнить: символ * относится к конкретному объявляемому имени, а не ко всей строке.

int *p, q;

Эта запись означает:

Если нужны два указателя, нужно написать:

int *p, *q;

Для начинающих безопаснее объявлять указатели отдельно:

int *p;
int *q;

Приведение типов указателей

Иногда адрес одного типа явно приводят к указателю другого типа.

int *pi;
char *pc;

pc = (char *)pi;

Такая запись называется приведением типа указателя. Она говорит компилятору: рассматривать значение pi как указатель на char.

На начальном этапе к таким преобразованиям нужно относиться осторожно. Приведение типа не меняет реальные данные в памяти. Оно только меняет то, как программа будет интерпретировать адрес.

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

Базовые операции над указателями

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

Некоторые из этих операций особенно важны при работе с массивами. Поэтому подробно арифметика указателей будет раскрыта в следующем пункте.

Сравнение указателей

Указатели можно сравнивать на равенство и неравенство.

int x = 10;
int y = 20;

int *p = &x;
int *q = &x;
int *r = &y;

if (p == q)
{
    printf("p and q point to the same object\n");
}

if (p != r)
{
    printf("p and r point to different objects\n");
}

Если два указателя хранят один и тот же адрес, они указывают на один и тот же объект.

Также часто проверяют указатель на NULL:

if (p != NULL)
{
    printf("%d\n", *p);
}

Увеличение и уменьшение указателя

К указателю можно применить ++ и --. Но указатель изменяется не просто на один байт, а на размер объекта, на который он указывает.

int a[5] = { 10, 20, 30, 40, 50 };
int *p = &a[0];

printf("%d\n", *p);

p++;

printf("%d\n", *p);

Сначала p указывает на a[0]. После p++ он указывает на следующий элемент, то есть на a[1].

Для int * переход на следующий элемент означает переход на размер одного int. Для double * — на размер одного double. Для char * — на размер одного char.

Арифметика указателей и тип объекта

Тип указателя определяет шаг при арифметике указателей.

char chars[3];
int numbers[3];
double values[3];

char *pc = &chars[0];
int *pi = &numbers[0];
double *pd = &values[0];

pc++;
pi++;
pd++;

Все три операции записаны одинаково, но фактически переход выполняется на разные расстояния в памяти:

Поэтому указатель — это не просто число. Его тип влияет на смысл операций.

Печать адресов: пример

Конкретные адреса при каждом запуске могут отличаться. Поэтому в учебных программах адреса используют для наблюдения, а не для запоминания конкретных чисел.

#include <stdio.h>

int main(void)
{
    int x = 10;
    int *p = &x;

    printf("x value     = %d\n", x);
    printf("x address   = %p\n", (void *)&x);
    printf("p value     = %p\n", (void *)p);
    printf("p address   = %p\n", (void *)&p);
    printf("*p value    = %d\n", *p);

    return 0;
}

Возможный смысл вывода:

Указатель и scanf

С операцией взятия адреса мы уже встречались при вводе через scanf.

int x;

scanf("%d", &x);

Функция scanf должна записать введённое значение в переменную x. Поэтому ей нужен адрес этой переменной.

Теперь это можно объяснить через указатели:

То есть многие функции в C работают с данными именно через адреса.

Мини-программа: обмен значений через указатели

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

#include <stdio.h>

int main(void)
{
    int a = 10;
    int b = 20;
    int temp;

    int *pa = &a;
    int *pb = &b;

    printf("before: a = %d, b = %d\n", a, b);

    temp = *pa;
    *pa = *pb;
    *pb = temp;

    printf("after:  a = %d, b = %d\n", a, b);

    return 0;
}

Здесь pa указывает на a, а pb указывает на b. Обмен выполняется не через имена a и b, а через разыменованные указатели *pa и *pb.

Когда указатели особенно полезны

В этом пункте указатели могут выглядеть как усложнение обычной работы с переменными. Например, вместо:

x = 10;

можно написать:

int *p = &x;
*p = 10;

Для такой простой задачи указатель действительно не нужен. Но указатели становятся важными, когда:

Поэтому сейчас главная цель — понять базовую механику: адрес, указатель, разыменование.

Типичные ошибки

Ошибка 1. Разыменование неинициализированного указателя

int *p;

*p = 10;

Указатель p не получил корректный адрес. Правильно:

int x;
int *p = &x;

*p = 10;

Ошибка 2. Разыменование NULL

int *p = NULL;

printf("%d\n", *p);

NULL означает отсутствие адреса объекта. Перед разыменованием нужно проверить указатель.

if (p != NULL)
{
    printf("%d\n", *p);
}

Ошибка 3. Путаница между p и *p

int x = 10;
int *p = &x;

printf("%p\n", (void *)p);  /* адрес */
printf("%d\n", *p);         /* значение по адресу */

p — это адрес. *p — это объект по этому адресу.

Ошибка 4. Неправильное объявление нескольких указателей

int *p, q;

Здесь только p является указателем. q — обычный int. Для двух указателей:

int *p, *q;

Ошибка 5. Попытка взять адрес выражения

int x = 10;
int *p = &(x + 1);

Выражение x + 1 не является отдельной переменной, у которой можно взять адрес.

Ошибка 6. Несовместимые типы указателей

int x = 10;
double *p = &x;

&x имеет тип «указатель на int», а p — указатель на double. Это разные типы указателей.

Ошибка 7. Неверный формат вывода адреса

int x = 10;

printf("%d\n", &x);

Для адресов используют %p:

printf("%p\n", (void *)&x);

Практические рекомендации

Мини-разбор программы

#include <stdio.h>

int main(void)
{
    int value = 15;
    int *p = &value;

    printf("value = %d\n", value);
    printf("address of value = %p\n", (void *)&value);
    printf("p = %p\n", (void *)p);
    printf("*p = %d\n", *p);

    *p = 40;

    printf("value after change = %d\n", value);

    return 0;
}

Разберём программу:

Что нужно запомнить

Самопроверка перед переходом дальше

  1. Что такое адрес переменной?
  2. Что делает операция &?
  3. Что такое указатель?
  4. Как объявить указатель на int?
  5. Что означает запись int *p = &x;?
  6. Чем отличается p от *p?
  7. Что делает операция разыменования?
  8. Почему можно изменить переменную через *p?
  9. Почему опасно разыменовывать неинициализированный указатель?
  10. Что означает NULL?
  11. Почему нельзя разыменовывать NULL?
  12. Что означает тип void *?
  13. Почему int *p, q; не объявляет два указателя?
  14. Как вывести адрес переменной через printf?
  15. Почему тип указателя важен при арифметике указателей?