4.2. Указатели и массивы

Теория

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

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

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

В этом пункте рассматриваются:

Имя массива и адрес первого элемента

Если объявлен массив:

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;
}

Здесь:

Адрес a + 5 указывает на позицию сразу после последнего элемента массива. Разыменовывать a + 5 нельзя, но сравнивать с ним указатель в условии цикла можно.

Арифметика указателей

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

Основные операции:

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++;

Эти три операции записаны одинаково, но смысл у них разный:

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

Пример: адреса элементов разных массивов

Следующая программа показывает, что адреса соседних элементов меняются с разным шагом для разных типов.

#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;
}

В этом примере:

Постфиксный инкремент при разыменовании

В выражениях с указателями часто встречается запись:

*p++

Её нужно читать внимательно. Постфиксный инкремент ++ имеет высокий приоритет, поэтому выражение обычно понимается как:

*(p++)

То есть:

  1. сначала используется значение указателя p;
  2. получается объект по адресу p;
  3. после этого сам указатель 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;

Здесь:

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

Пример: динамическая матрица одинаковой ширины

#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;

Здесь:

Такой подход удобен, если строки имеют разное количество элементов:

строка 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);

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

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

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

#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;
}

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

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

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

  1. Что означает имя массива без индекса?
  2. Чему эквивалентна запись a[i]?
  3. Чему эквивалентна запись &a[i]?
  4. Почему можно написать int *p = a;?
  5. Почему нельзя написать a++?
  6. Что делает операция p++, если p — указатель на элемент массива?
  7. Почему шаг указателя зависит от типа элемента?
  8. Что показывает разность двух указателей внутри одного массива?
  9. Почему нельзя разыменовывать a + n для массива из n элементов?
  10. Чем *p++ отличается от (*p)++?
  11. Как получить количество элементов настоящего массива через sizeof?
  12. Почему этот приём не работает для динамического массива через указатель?
  13. Для чего используется malloc?
  14. Чем calloc отличается от malloc?
  15. Зачем нужна функция free?
  16. Что такое массив указателей?
  17. Как можно организовать двумерный динамический массив через массив указателей?