4.2. Указатели и массивы
Теория
Зачем нужен этот пункт
В предыдущем пункте были рассмотрены адреса объектов и первые действия с указателями. Теперь нужно понять, почему указатели особенно тесно связаны с массивами.
В языке C имя массива во многих выражениях ведёт себя как адрес его первого элемента. Поэтому массив можно обрабатывать не только через индексы, но и через указатели.
В этом пункте рассматриваются:
- имя массива как адрес первого элемента;
- связь записей
a[i]и*(a + i); - связь записей
&a[i]иa + i; - обход массива с помощью указателя;
- арифметика указателей;
- разворот массива через два указателя;
- различие между массивом и указателем;
- использование
sizeofс массивом и указателем; - динамические массивы;
- массивы указателей;
- моделирование двумерных массивов через указатели.
Имя массива и адрес первого элемента
Если объявлен массив:
int a[5] = { 10, 20, 30, 40, 50 };
то его элементы имеют имена:
a[0], a[1], a[2], a[3], a[4]
Во многих выражениях имя массива a преобразуется
в адрес первого элемента массива, то есть в адрес a[0].
a /* адрес первого элемента */
&a[0] /* адрес первого элемента */
Поэтому следующие выражения указывают на одно и то же место:
a == &a[0]
Это одно из главных правил, на котором строится связь массивов и указателей в языке C.
Адрес элемента массива
Адрес любого элемента массива можно получить через операцию
&.
int a[5];
&a[0]
&a[1]
&a[2]
&a[3]
&a[4]
Но так как имя массива во многих выражениях обозначает адрес первого
элемента, адрес элемента с индексом i можно записать иначе:
a + i
Поэтому:
&a[i] == a + i
Например:
&a[0] == a + 0
&a[1] == a + 1
&a[2] == a + 2
Запись a + i означает не «прибавить i байтов», а перейти
к элементу массива с номером i. Размер шага зависит
от типа элементов массива.
Доступ к элементу через указатель
Если a + i — это адрес элемента a[i], то
разыменование этого адреса даёт сам элемент.
*(a + i)
Поэтому:
a[i] == *(a + i)
Например:
int a[5] = { 10, 20, 30, 40, 50 };
printf("%d\n", a[2]);
printf("%d\n", *(a + 2));
Оба вызова printf выведут одно и то же значение:
30.
Индексная форма и указательная форма
В языке C операция индексирования устроена через указатели. Общая форма:
E1[E2]
эквивалентна:
*(E1 + E2)
Для массива это означает:
a[i] == *(a + i)
А адрес элемента:
&a[i] == a + i
В обычном коде чаще используют индексную форму a[i],
потому что она читается проще. Указательная форма нужна для понимания
внутренней связи массивов и указателей, а также для некоторых приёмов
обработки массивов.
Пример: вывод массива двумя способами
#include <stdio.h>
int main(void)
{
int a[5] = { 10, 20, 30, 40, 50 };
int i;
printf("Вывод через индексы:\n");
for (i = 0; i < 5; i++)
{
printf("%d ", a[i]);
}
printf("\nВывод через указательную форму:\n");
for (i = 0; i < 5; i++)
{
printf("%d ", *(a + i));
}
printf("\n");
return 0;
}
Оба цикла выводят одни и те же элементы массива.
В первом цикле используется привычная запись a[i],
во втором — разыменование адреса a + i.
Массив и указатель: похожи, но не одно и то же
Имя массива во многих выражениях превращается в адрес первого элемента, но сам массив не является обычной переменной-указателем.
int a[5];
int *p;
p = a; /* можно: p получает адрес первого элемента */
p = &a[0]; /* тоже можно */
Но имя массива нельзя изменить:
a = p; /* ошибка */
a++; /* ошибка */
Указатель p — это переменная. Ему можно присваивать
новые адреса, его можно увеличивать и уменьшать.
p = &a[0];
p++;
p = &a[3];
А имя массива a обозначает начало области памяти,
выделенной под массив. Его нельзя передвинуть на другой элемент.
Указатель на первый элемент массива
Указатель можно направить на первый элемент массива.
int a[5] = { 10, 20, 30, 40, 50 };
int *p = a;
Запись int *p = a; означает то же самое, что:
int *p = &a[0];
Теперь через p можно обращаться к элементам массива:
printf("%d\n", *p); /* a[0] */
printf("%d\n", *(p + 1)); /* a[1] */
printf("%d\n", *(p + 2)); /* a[2] */
Также можно использовать индексную форму:
printf("%d\n", p[0]);
printf("%d\n", p[1]);
printf("%d\n", p[2]);
Если указатель указывает на начало массива, с ним можно работать почти так же, как с именем массива. Но сам указатель можно изменять, а имя массива — нет.
Обход массива через указатель
Один из типичных приёмов — пройти по массиву с помощью указателя.
#include <stdio.h>
int main(void)
{
int a[5] = { 10, 20, 30, 40, 50 };
int *p;
for (p = a; p < a + 5; p++)
{
printf("%d ", *p);
}
printf("\n");
return 0;
}
Здесь:
p = a— указатель становится на первый элемент;p < a + 5— цикл продолжается, пока указатель не вышел за последний элемент;p++— переход к следующему элементу;*p— значение текущего элемента.
Адрес a + 5 указывает на позицию сразу после последнего
элемента массива. Разыменовывать a + 5 нельзя, но сравнивать
с ним указатель в условии цикла можно.
Арифметика указателей
Арифметика указателей — это операции, которые позволяют переходить от одного элемента массива к другому.
Основные операции:
p + n— адрес элемента, расположенного наnпозиций дальше;p - n— адрес элемента, расположенного наnпозиций раньше;p++— переход к следующему элементу;p--— переход к предыдущему элементу;p2 - p1— расстояние между двумя указателями в элементах, если они относятся к одному массиву.
int a[5] = { 10, 20, 30, 40, 50 };
int *p = a;
printf("%d\n", *(p + 0)); /* 10 */
printf("%d\n", *(p + 1)); /* 20 */
printf("%d\n", *(p + 4)); /* 50 */
Шаг указателя зависит от типа
Когда указатель увеличивается на единицу, он переходит к следующему элементу своего типа, а не просто к следующему байту.
char c[5];
int i[5];
double d[5];
char *pc = c;
int *pi = i;
double *pd = d;
pc++;
pi++;
pd++;
Эти три операции записаны одинаково, но смысл у них разный:
pc++переходит к следующемуchar;pi++переходит к следующемуint;pd++переходит к следующемуdouble.
Поэтому указатель нельзя воспринимать как простое целое число. Его тип определяет, как именно выполняется переход по памяти.
Пример: адреса элементов разных массивов
Следующая программа показывает, что адреса соседних элементов меняются с разным шагом для разных типов.
#include <stdio.h>
int main(void)
{
char chars[5];
int numbers[5];
double values[5];
char *pc;
int *pi;
double *pd;
printf("Адреса элементов char-массива:\n");
for (pc = chars; pc < chars + 5; pc++)
{
printf("%p\n", (void *)pc);
}
printf("\nАдреса элементов int-массива:\n");
for (pi = numbers; pi < numbers + 5; pi++)
{
printf("%p\n", (void *)pi);
}
printf("\nАдреса элементов double-массива:\n");
for (pd = values; pd < values + 5; pd++)
{
printf("%p\n", (void *)pd);
}
return 0;
}
Конкретные адреса при запуске могут отличаться. Главное наблюдение: при переходе к следующему элементу указатель смещается на размер соответствующего типа.
Разность указателей
Если два указателя указывают на элементы одного массива, их можно вычитать.
int a[5] = { 10, 20, 30, 40, 50 };
int *p1 = &a[1];
int *p2 = &a[4];
printf("%td\n", p2 - p1);
Результат будет 3, потому что между a[1]
и a[4] три позиции.
Важно: разность указателей показывает расстояние в элементах, а не в байтах.
Вычитать указатели, относящиеся к разным независимым массивам, нельзя считать корректным приёмом. Такая операция не имеет надёжного смысла.
Сравнение указателей внутри массива
Указатели на элементы одного массива можно сравнивать.
int a[5] = { 10, 20, 30, 40, 50 };
int *left = &a[0];
int *right = &a[4];
if (left < right)
{
printf("left находится раньше right\n");
}
Такое сравнение удобно, например, при движении двух указателей навстречу друг другу.
Сравнение указателей на элементы разных независимых массивов использовать не следует: порядок таких адресов не имеет переносимого логического смысла для программы.
Разворот массива через два указателя
Рассмотрим задачу: нужно развернуть массив, то есть поменять местами первый элемент с последним, второй с предпоследним и так далее.
#include <stdio.h>
int main(void)
{
int a[6] = { 1, 2, 3, 4, 5, 6 };
int *left = a;
int *right = a + 5;
int temp;
int i;
while (left < right)
{
temp = *left;
*left = *right;
*right = temp;
left++;
right--;
}
for (i = 0; i < 6; i++)
{
printf("%d ", a[i]);
}
printf("\n");
return 0;
}
В этом примере:
leftсначала указывает на первый элемент;rightсначала указывает на последний элемент;- на каждой итерации значения
*leftи*rightменяются местами; left++двигает левый указатель вправо;right--двигает правый указатель влево;- цикл заканчивается, когда указатели встретились или пересеклись.
Постфиксный инкремент при разыменовании
В выражениях с указателями часто встречается запись:
*p++
Её нужно читать внимательно. Постфиксный инкремент ++
имеет высокий приоритет, поэтому выражение обычно понимается как:
*(p++)
То есть:
- сначала используется значение указателя
p; - получается объект по адресу
p; - после этого сам указатель
pувеличивается и начинает указывать на следующий элемент.
int a[3] = { 10, 20, 30 };
int *p = a;
printf("%d\n", *p++); /* выводит 10, потом p переходит к a[1] */
printf("%d\n", *p); /* выводит 20 */
Если нужно увеличить именно значение элемента, а не указатель, нужно писать иначе:
(*p)++;
Разворот массива с постфиксными операциями
Предыдущий разворот массива можно записать компактнее:
#include <stdio.h>
int main(void)
{
char z[6] = { 'a', 'b', 'c', 'd', 'e', 'f' };
char *left = z;
char *right = z + 5;
char temp;
int i;
while (left < right)
{
temp = *left;
*left++ = *right;
*right-- = temp;
}
for (i = 0; i < 6; i++)
{
printf("%c ", z[i]);
}
printf("\n");
return 0;
}
Строка:
*left++ = *right;
означает: записать значение *right в текущий элемент
*left, а затем передвинуть указатель left
на следующий элемент.
Строка:
*right-- = temp;
означает: записать temp в текущий элемент
*right, а затем передвинуть указатель right
на предыдущий элемент.
Такая запись короче, но для начинающих её нужно использовать осторожно: сначала важно хорошо понимать порядок действий.
Указательная форма для обычного цикла
Вместо цикла с индексом:
for (i = 0; i < n; i++)
{
sum += a[i];
}
можно использовать цикл с указателем:
for (p = a; p < a + n; p++)
{
sum += *p;
}
Полный пример:
#include <stdio.h>
int main(void)
{
int a[5] = { 4, 7, 1, 9, 3 };
int *p;
int sum = 0;
for (p = a; p < a + 5; p++)
{
sum += *p;
}
printf("sum = %d\n", sum);
return 0;
}
Оба подхода правильные. Индексная форма обычно понятнее для новичка, а указательная форма полезна для глубокого понимания C и для работы с функциями обработки массивов.
Изменение массива через указатель
Через указатель можно изменять элементы массива.
#include <stdio.h>
int main(void)
{
int a[5] = { 1, 2, 3, 4, 5 };
int *p;
int i;
for (p = a; p < a + 5; p++)
{
*p = *p * 10;
}
for (i = 0; i < 5; i++)
{
printf("%d ", a[i]);
}
printf("\n");
return 0;
}
На каждой итерации p указывает на очередной элемент массива,
а выражение *p является самим элементом. Поэтому запись:
*p = *p * 10;
изменяет текущий элемент массива.
Многомерные массивы и указатели
Для двумерного массива:
int matrix[3][4];
элемент выбирается двумя индексами:
matrix[i][j]
В C двумерный массив — это массив строк, где каждая строка сама является массивом.
Для понимания можно рассуждать так:
matrix[i] /* строка с номером i */
matrix[i][j] /* элемент j внутри строки i */
Указательная эквивалентность сохраняется:
matrix[i][j] == *(*(matrix + i) + j)
На начальном этапе не обязательно постоянно писать такую форму. Достаточно понимать, что даже обычная запись с индексами связана с адресной арифметикой.
sizeof для массива
Операция sizeof позволяет узнать размер объекта в байтах.
Если применить sizeof к настоящему массиву, получится
размер всего массива.
int a[10];
printf("%zu\n", sizeof(a));
Если int занимает 4 байта, то массив из 10 элементов
займёт 40 байт.
Количество элементов настоящего массива можно вычислить так:
sizeof(a) / sizeof(a[0])
Пример:
#include <stdio.h>
int main(void)
{
int a[10];
size_t count;
count = sizeof(a) / sizeof(a[0]);
printf("Количество элементов: %zu\n", count);
return 0;
}
sizeof для указателя
Если применить sizeof к указателю, получится размер самого
указателя, а не размер массива, на который он указывает.
int a[10];
int *p = a;
printf("%zu\n", sizeof(a)); /* размер всего массива */
printf("%zu\n", sizeof(p)); /* размер указателя */
Это важное различие. Если массив передан в функцию как параметр,
внутри функции параметр фактически является указателем, и
sizeof уже не покажет размер исходного массива.
void printSize(int a[])
{
printf("%zu\n", sizeof(a)); /* размер указателя, не массива */
}
Поэтому размер массива обычно передают в функцию отдельным параметром.
Динамический массив
Обычный массив фиксированного размера объявляется так:
int a[100];
Его размер задан в тексте программы. Но иногда размер нужен только во время выполнения: пользователь вводит количество элементов, программа читает файл, размер данных заранее неизвестен.
В таких ситуациях используют динамическое выделение памяти.
Для этого нужны функции из заголовочного файла stdlib.h.
#include <stdlib.h>
Основные функции:
| Функция | Назначение |
|---|---|
malloc |
выделяет блок памяти заданного размера |
calloc |
выделяет память под несколько элементов и заполняет её нулями |
realloc |
изменяет размер ранее выделенного блока |
free |
освобождает ранее выделенную память |
malloc
Функция malloc выделяет блок памяти указанного размера
в байтах и возвращает адрес начала этого блока.
void *malloc(size_t size);
Для массива из n элементов типа int нужно
выделить:
n * sizeof(int)
Пример:
int *a;
int n = 10;
a = malloc(n * sizeof(int));
После этого с a можно работать как с массивом:
a[0] = 10;
a[1] = 20;
Если память выделить не удалось, malloc возвращает
NULL. Поэтому результат нужно проверять.
Пример: динамический массив чисел
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
int n;
int i;
int *a;
printf("Введите количество элементов: ");
scanf("%d", &n);
if (n <= 0)
{
printf("Ошибка: количество должно быть положительным\n");
return 0;
}
a = malloc(n * sizeof(int));
if (a == NULL)
{
printf("Ошибка выделения памяти\n");
return 0;
}
for (i = 0; i < n; i++)
{
printf("a[%d] = ", i);
scanf("%d", &a[i]);
}
printf("Массив в обратном порядке:\n");
for (i = n - 1; i >= 0; i--)
{
printf("%d ", a[i]);
}
printf("\n");
free(a);
return 0;
}
В этой программе размер массива вводится пользователем. Память
выделяется через malloc, используется как массив,
а затем освобождается через free.
Почему нужен free
Память, выделенную через malloc, calloc
или realloc, нужно освобождать через free.
int *a = malloc(n * sizeof(int));
/* работа с массивом */
free(a);
Если не освобождать динамическую память, программа может создавать утечки памяти. В маленькой учебной программе это может быть незаметно, но в больших программах такая ошибка становится серьёзной.
После free(a) указатель a больше нельзя
разыменовывать.
free(a);
/* a[0] = 10; ошибка: память уже освобождена */
Хорошая привычка после освобождения памяти присваивать указателю
NULL.
free(a);
a = NULL;
calloc
Функция calloc выделяет память под несколько элементов
и заполняет выделенный блок нулями.
void *calloc(size_t count, size_t size);
Пример:
int *a;
int n = 10;
a = calloc(n, sizeof(int));
Здесь выделяется память под n элементов типа
int. В отличие от malloc, память после
calloc будет обнулена.
Но результат всё равно нужно проверять:
if (a == NULL)
{
printf("Ошибка выделения памяти\n");
return 0;
}
realloc
Функция realloc изменяет размер ранее выделенного блока
памяти.
void *realloc(void *ptr, size_t newSize);
Например, если нужно увеличить динамический массив:
int *temp;
temp = realloc(a, newN * sizeof(int));
if (temp == NULL)
{
printf("Не удалось изменить размер массива\n");
}
else
{
a = temp;
n = newN;
}
Важно использовать временный указатель temp. Если сразу
написать:
a = realloc(a, newN * sizeof(int));
и realloc завершится неудачно, можно потерять старый адрес
и получить утечку памяти.
sizeof и динамический массив
Для динамического массива нельзя узнать количество элементов через:
sizeof(a) / sizeof(a[0])
если a — это указатель.
int *a = malloc(n * sizeof(int));
printf("%zu\n", sizeof(a));
Здесь sizeof(a) показывает размер указателя,
а не размер выделенного блока памяти.
Поэтому для динамических массивов количество элементов нужно хранить отдельно:
int n;
int *a;
Массив указателей
Массив может хранить не только числа или символы, но и указатели.
int *pointers[5];
Это массив из 5 элементов. Каждый элемент имеет тип
int *, то есть является указателем на int.
Пример:
int data[5] = { 10, 20, 30, 40, 50 };
int *pointers[3];
pointers[0] = &data[0];
pointers[1] = &data[2];
pointers[2] = &data[4];
Теперь:
*pointers[0] == data[0]
*pointers[1] == data[2]
*pointers[2] == data[4]
Массивы указателей особенно важны при работе со строками, таблицами строк, динамическими двумерными массивами и аргументами командной строки.
Пример: массив указателей на элементы
#include <stdio.h>
int main(void)
{
int data[5] = { 10, 20, 30, 40, 50 };
int *p[3];
int i;
p[0] = &data[0];
p[1] = &data[2];
p[2] = &data[4];
for (i = 0; i < 3; i++)
{
printf("%d\n", *p[i]);
}
return 0;
}
Здесь p — массив указателей. Каждый элемент массива
p хранит адрес некоторого элемента массива
data.
Запись *p[i] означает: взять указатель p[i]
и разыменовать его.
Динамический двумерный массив: идея
Обычный двумерный массив фиксированного размера:
int matrix[3][4];
удобен, когда размеры известны заранее. Если размеры вводятся пользователем, можно использовать динамическую память.
Один из вариантов — создать массив указателей на строки:
int **matrix;
Здесь:
matrix— указатель на массив указателей;matrix[i]— указатель на строку с номеромi;matrix[i][j]— элемент строкиiи столбцаj.
Такой подход позволяет выделять память для строк во время выполнения программы.
Пример: динамическая матрица одинаковой ширины
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
int rows;
int cols;
int i;
int j;
int **matrix;
printf("Введите количество строк: ");
scanf("%d", &rows);
printf("Введите количество столбцов: ");
scanf("%d", &cols);
if (rows <= 0 || cols <= 0)
{
printf("Ошибка размеров\n");
return 0;
}
matrix = malloc(rows * sizeof(int *));
if (matrix == NULL)
{
printf("Ошибка выделения памяти\n");
return 0;
}
for (i = 0; i < rows; i++)
{
matrix[i] = malloc(cols * sizeof(int));
if (matrix[i] == NULL)
{
printf("Ошибка выделения памяти для строки\n");
while (i > 0)
{
i--;
free(matrix[i]);
}
free(matrix);
return 0;
}
}
for (i = 0; i < rows; i++)
{
for (j = 0; j < cols; j++)
{
matrix[i][j] = i + j;
}
}
for (i = 0; i < rows; i++)
{
for (j = 0; j < cols; j++)
{
printf("%4d", matrix[i][j]);
}
printf("\n");
}
for (i = 0; i < rows; i++)
{
free(matrix[i]);
}
free(matrix);
return 0;
}
Здесь сначала выделяется массив указателей на строки, затем отдельно
выделяется память под каждую строку. В конце каждая строка
освобождается через free, а затем освобождается сам массив
указателей.
«Рваный» двумерный массив
Если каждая строка может иметь свою длину, получается так называемый «рваный» массив: строки есть, но они необязательно одинаковой длины.
double **lines;
int *lengths;
Здесь:
lines— массив указателей на строки;lines[i]— указатель на строку с номеромi;lengths[i]— количество элементов в строкеi.
Такой подход удобен, если строки имеют разное количество элементов:
строка 0: 4 элемента
строка 1: 3 элемента
строка 2: 1 элемент
строка 3: 4 элемента
Обычный прямоугольный массив хранил бы лишние неиспользуемые элементы, а массив указателей позволяет выделить каждой строке ровно столько памяти, сколько нужно.
Пример: строки разной длины
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
double **lines;
int *lengths;
int rows;
int i;
int j;
printf("Введите количество строк: ");
scanf("%d", &rows);
if (rows <= 0)
{
printf("Ошибка: количество строк должно быть положительным\n");
return 0;
}
lines = calloc(rows, sizeof(double *));
lengths = malloc(rows * sizeof(int));
if (lines == NULL || lengths == NULL)
{
printf("Ошибка выделения памяти\n");
free(lines);
free(lengths);
return 0;
}
for (i = 0; i < rows; i++)
{
printf("Введите длину строки %d: ", i);
scanf("%d", &lengths[i]);
if (lengths[i] <= 0)
{
printf("Ошибка длины строки\n");
while (i > 0)
{
i--;
free(lines[i]);
}
free(lines);
free(lengths);
return 0;
}
lines[i] = malloc(lengths[i] * sizeof(double));
if (lines[i] == NULL)
{
printf("Ошибка выделения памяти для строки\n");
while (i > 0)
{
i--;
free(lines[i]);
}
free(lines);
free(lengths);
return 0;
}
for (j = 0; j < lengths[i]; j++)
{
printf("lines[%d][%d] = ", i, j);
scanf("%lf", &lines[i][j]);
}
}
printf("\nВывод строк в обратном порядке:\n");
for (i = rows - 1; i >= 0; i--)
{
printf("Строка %d: ", i);
for (j = 0; j < lengths[i]; j++)
{
printf("%.2f ", lines[i][j]);
}
printf("\n");
}
for (i = 0; i < rows; i++)
{
free(lines[i]);
}
free(lines);
free(lengths);
return 0;
}
В этой программе каждая строка выделяется отдельно. Поэтому длины строк могут быть разными.
Различие malloc и calloc
| Функция | Как задаётся размер | Что с начальными значениями |
|---|---|---|
malloc |
общее количество байтов | содержимое не инициализируется |
calloc |
количество элементов и размер одного элемента | память заполняется нулями |
int *a = malloc(n * sizeof(int));
int *b = calloc(n, sizeof(int));
После malloc элементы массива a имеют
неопределённые значения, пока программа сама их не заполнит.
После calloc элементы массива b будут
обнулены.
Правильная формула выделения памяти
При выделении памяти под массив лучше использовать такую форму:
a = malloc(n * sizeof(a[0]));
Например:
int *a;
a = malloc(n * sizeof(a[0]));
Это удобно, потому что если тип указателя изменится, выражение
sizeof(a[0]) автоматически останется согласованным
с типом элемента.
Для массива double:
double *x;
x = malloc(n * sizeof(x[0]));
Такая запись уменьшает риск ошибки в размере выделяемой памяти.
Типичные ошибки
Ошибка 1. Попытка изменить имя массива
int a[5];
a++; /* ошибка */
a = NULL; /* ошибка */
Имя массива не является переменной-указателем. Его нельзя изменить.
Ошибка 2. Выход за границы массива
int a[5];
printf("%d\n", *(a + 5));
В массиве из 5 элементов допустимы индексы от 0
до 4. Адрес a + 5 указывает за последний
элемент, разыменовывать его нельзя.
Ошибка 3. Неверное понимание p++
int a[5];
int *p = a;
p++;
Указатель переходит к следующему элементу, а не просто увеличивается на один байт.
Ошибка 4. Путаница между *p++ и (*p)++
*p++; /* используется *p, затем увеличивается p */
(*p)++; /* увеличивается значение элемента */
Эти записи делают разные вещи.
Ошибка 5. Использование sizeof для динамического массива
int *a = malloc(n * sizeof(int));
count = sizeof(a) / sizeof(a[0]); /* ошибка по смыслу */
sizeof(a) — это размер указателя, а не размер выделенного
блока. Количество элементов нужно хранить отдельно.
Ошибка 6. Не проверили результат malloc
int *a = malloc(n * sizeof(int));
a[0] = 10;
Если malloc вернул NULL, обращение
a[0] приведёт к ошибке. Нужно проверять результат.
Ошибка 7. Забыли free
int *a = malloc(n * sizeof(int));
/* работа с a */
/* free(a) забыли */
Память, выделенную динамически, нужно освобождать.
Ошибка 8. Использование памяти после free
free(a);
a[0] = 10; /* ошибка */
После освобождения памяти указатель больше не должен использоваться для доступа к старому блоку.
Ошибка 9. Освободили только массив указателей, но не строки
int **matrix;
/* строки выделялись отдельно */
free(matrix);
Если каждая строка выделялась отдельно, сначала нужно освободить строки, а потом сам массив указателей.
for (i = 0; i < rows; i++)
{
free(matrix[i]);
}
free(matrix);
Практические рекомендации
- Помни: имя массива во многих выражениях — это адрес первого элемента.
- Запись
a[i]эквивалентна*(a + i). - Запись
&a[i]эквивалентнаa + i. - Не пытайся изменить имя массива через
a++или присваивание. - Для обхода массива можно использовать индексы или указатели.
- Не выходи за границы массива при указательной арифметике.
- Помни, что шаг указателя зависит от типа элемента.
- Для настоящего массива количество элементов можно получить через
sizeof(a) / sizeof(a[0]). - Для динамического массива размер нужно хранить отдельно.
- Всегда проверяй результат
malloc,callocиrealloc. - Освобождай динамическую память через
free. - После
freeне используй старый блок памяти. - Если выделяешь двумерный массив построчно, освобождай каждую строку отдельно.
Мини-разбор программы
Программа создаёт динамический массив, вводит элементы, считает сумму через указатель и выводит массив в обратном порядке.
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
int n;
int i;
int *a;
int *p;
int sum = 0;
printf("Введите n: ");
scanf("%d", &n);
if (n <= 0)
{
printf("Ошибка: n должно быть положительным\n");
return 0;
}
a = malloc(n * sizeof(a[0]));
if (a == NULL)
{
printf("Ошибка выделения памяти\n");
return 0;
}
for (i = 0; i < n; i++)
{
printf("a[%d] = ", i);
scanf("%d", &a[i]);
}
for (p = a; p < a + n; p++)
{
sum += *p;
}
printf("Сумма = %d\n", sum);
printf("Массив в обратном порядке:\n");
for (p = a + n - 1; p >= a; p--)
{
printf("%d ", *p);
}
printf("\n");
free(a);
a = NULL;
return 0;
}
Разберём программу:
a— указатель на начало динамического массива;malloc(n * sizeof(a[0]))выделяет память подnэлементов;a[i]используется как обычный элемент массива;p = aставит указатель на первый элемент;p < a + nограничивает обход границами массива;*pдаёт значение текущего элемента;p++переходит к следующему элементу;free(a)освобождает выделенную память.
Что нужно запомнить
- Имя массива во многих выражениях преобразуется в адрес первого элемента.
aи&a[0]указывают на первый элемент массива.&a[i]эквивалентноa + i.a[i]эквивалентно*(a + i).- Указатель можно передвигать по массиву с помощью
++,--,+и-. - Шаг указателя зависит от типа элемента массива.
- Имя массива нельзя изменять, а указатель-переменную можно.
- Адрес сразу после последнего элемента можно использовать для сравнения, но нельзя разыменовывать.
- Разность двух указателей внутри одного массива даёт расстояние в элементах.
sizeofдля настоящего массива даёт размер всего массива.sizeofдля указателя даёт размер указателя, а не динамического массива.- Динамическая память выделяется через
malloc,calloc,realloc. - Динамическая память освобождается через
free. - Массив указателей хранит адреса объектов или других массивов.
- Динамический двумерный массив часто строится как массив указателей на строки.
Самопроверка перед переходом дальше
- Что означает имя массива без индекса?
- Чему эквивалентна запись
a[i]? - Чему эквивалентна запись
&a[i]? - Почему можно написать
int *p = a;? - Почему нельзя написать
a++? - Что делает операция
p++, еслиp— указатель на элемент массива? - Почему шаг указателя зависит от типа элемента?
- Что показывает разность двух указателей внутри одного массива?
- Почему нельзя разыменовывать
a + nдля массива изnэлементов? - Чем
*p++отличается от(*p)++? - Как получить количество элементов настоящего массива через
sizeof? - Почему этот приём не работает для динамического массива через указатель?
- Для чего используется
malloc? - Чем
callocотличается отmalloc? - Зачем нужна функция
free? - Что такое массив указателей?
- Как можно организовать двумерный динамический массив через массив указателей?