bulgakov

40. Указатели в функциях: swap, scanf и два результата

Если функции нужно изменить переменную снаружи, ей передают адрес этой переменной. Раньше мы передавали значения, и функция могла менять только свою копию. Теперь разберём, почему так, и как три уже знакомые вещи на самом деле объясняются одним приёмом: swap, scanf и функции с несколькими результатами. Основа — указатели.

Что пригодится из прошлого: свои функции, указатели, сортировка по функциям. Если эти темы знакомы, читайте дальше. Если нет — загляните по ссылке, потом возвращайтесь.

Параметр — это копия

Напишем функцию, которая меняет два числа местами, и вызовем её в самом очевидном виде. Полная программа:

C
#include <stdio.h>

void swap(int a, int b)
{
    int tmp = a;
    a = b;
    b = tmp;
}

int main(void)
{
    int x = 1;
    int y = 2;

    swap(x, y);
    printf("x = %d, y = %d\n", x, y);
    return 0;
}

Вывод:

x = 1, y = 2

Числа не поменялись. Причина в том, что при вызове swap(x, y) значения x и y копируются в параметры a и b. Функция честно переставила свои копии, но на исходные x и y в main это не повлияло. Это то же правило, что и для параметров в уроке про свои функции.

Картинкой:

Схема
main:        x = 1          y = 2
               │ копия        │ копия
               ▼              ▼
swap:        a = 1          b = 2      ← меняются только эти копии

Как передать не копию, а место

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

Полная программа:

C
#include <stdio.h>

void swap(int *a, int *b)
{
    int tmp = *a;
    *a = *b;
    *b = tmp;
}

int main(void)
{
    int x = 1;
    int y = 2;

    swap(&x, &y);
    printf("x = %d, y = %d\n", x, y);
    return 0;
}

Вывод:

x = 2, y = 1

Теперь всё работает. Посмотрим на отличия.

  • Параметры объявлены как int *a, int *b: функция принимает два указателя.
  • Вызов swap(&x, &y) передаёт адреса переменных, а не значения.
  • Внутри *a и *b — это сами x и y. Три строки с tmp меняют их местами так же, как в сортировке.

Схема вызова:

Схема
main:   x = 1     y = 2
          ▲         ▲
          │         │
swap:     a         b       (a хранит &x, b хранит &y)

tmp = *a;   → tmp = 1
*a  = *b;   → x = 2
*b  = tmp;  → y = 1

Так же можно менять элементы массива. Адрес элемента пишется &arr[i]:

C
#include <stdio.h>

void swap(int *a, int *b)
{
    int tmp = *a;
    *a = *b;
    *b = tmp;
}

int main(void)
{
    int arr[] = {5, 3, 8};

    swap(&arr[0], &arr[2]);
    for (int i = 0; i < 3; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
    return 0;
}

Вывод:

8 3 5 

Вызов swap(&arr[0], &arr[2]) поменял первый и последний элементы массива 5 3 8.

Тайна scanf раскрыта

Теперь понятно, зачем в scanf("%d", &x) стоит &. Функции scanf нужно записать число в x. Для записи надо знать, где x лежит, и ей передают адрес. Функция printf только читает значение, ей хватает копии.

Тот же приём можно использовать в своей функции. Параметр a типа int * уже является адресом, поэтому в scanf его передают без &:

C
#include <stdio.h>

int read_int(int *a)
{
    return scanf("%d", a) == 1;
}

int main(void)
{
    int n;
    if (!read_int(&n)) {
        printf("Input error\n");
        return 1;
    }
    printf("n = %d\n", n);
    return 0;
}

Ввод:

42

Вывод:

n = 42

В main пишем read_int(&n) и передаём адрес переменной n. Внутри read_int параметр a содержит этот адрес. Поэтому scanf("%d", a) записывает прямо в n. Если написать scanf("%d", &a), получится адрес самой переменной a, лежащей внутри функции. Это адрес указателя, а не числа, и запись пойдёт не туда.

Функция с двумя результатами

return возвращает одно значение. Если результатов два, функции передают адреса «пустых коробок», куда она сама положит ответы. Например, частное и остаток:

C
#include <stdio.h>

void divmod(int a, int b, int *q, int *r)
{
    *q = a / b;
    *r = a % b;
}

int main(void)
{
    int q, r;

    divmod(17, 5, &q, &r);
    printf("q = %d, r = %d\n", q, r);
    return 0;
}

Вывод:

q = 3, r = 2

Вызов divmod(17, 5, &q, &r) передал адреса q и r. Функция вычислила 17 / 5 = 3 и 17 % 5 = 2 и записала их через *q и *r. После возврата main видит оба числа. (В учебном примере нет защиты от b == 0: деление на ноль в настоящей программе нужно проверять заранее.)

Как это связано с массивами

В уроке про пузырьковую сортировку по функциям функция swapArrayElements(arr, i) меняла настоящий массив. Теперь можно объяснить, почему. Когда массив передаётся в функцию, функция получает адрес его первого элемента, а не копию всех элементов. Поэтому она работает с исходными элементами, и изменения видны в main. Проверим это программой. В ней две функции одинаково считают сумму, но параметр записан по-разному:

C
#include <stdio.h>

int sum_with_brackets(int arr[], int size)
{
    int sum = 0;
    for (int i = 0; i < size; i++) {
        sum += arr[i];
    }
    return sum;
}

int sum_with_star(int *arr, int size)
{
    int sum = 0;
    for (int i = 0; i < size; i++) {
        sum += arr[i];
    }
    return sum;
}

int main(void)
{
    int arr[] = {5, 3, 8};

    printf("%d\n", arr == &arr[0]);
    printf("%d\n", sum_with_brackets(arr, 3));
    printf("%d\n", sum_with_star(arr, 3));
    return 0;
}

Вывод:

1
16
16

Первая строка: имя массива arr и адрес его первого элемента &arr[0] — одно и то же, сравнение даёт 1. Остальные строки: записи int arr[] и int *arr в параметре функции означают одно и то же — «адрес первого элемента». Поэтому внутри можно писать arr[i], как и с настоящим массивом: arr[i] — это «элемент, лежащий на i мест дальше адреса arr». Уточнение: имя массива превращается в адрес первого элемента, когда его передают в функцию или сравнивают. Исключение — sizeof(arr) там, где массив объявлен: он даёт размер всего массива, как мы видели в прошлом уроке.

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

Правило

Указатель нужен, когда функция должна изменить переменную снаружи. Если функции достаточно прочитать значение, передают значение.

Проверка на минуту

Вопрос 1: почему swap(x, y) с параметрами int не меняет x и y

Функция получила копии и поменяла их у себя. Исходные переменные не затронуты. Чтобы изменить их, нужно передать адреса: swap(&x, &y), а параметры объявить как int *.

Вопрос 2: что писать внутри read_int — scanf с a или с &a

Без &: scanf("%d", a). Параметр a уже содержит адрес. Запись &a даёт адрес самого указателя, а это не то место, куда надо записывать число.

Что будет дальше

В следующих темах курса будут функция, которая возвращает адрес, указатель на указатель (int **) и просмотр того, из каких байтов состоит число (у многих компьютеров младший байт идёт первым). В этой главе эти темы не разбираются.

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

  • Параметры функции — копии. Чтобы изменить переменную вызывающего, передают её адрес.
  • swap(&x, &y), scanf("%d", &x) и divmod(17, 5, &q, &r) — один и тот же приём.
  • Внутри функции с параметром int *a значение — *a, адрес — a.
  • Массив передаётся по адресу первого элемента, поэтому функция может менять его элементы.
ПрактикаЗагружаем тест…