40. Указатели в функциях: swap, scanf и два результата
Если функции нужно изменить переменную снаружи, ей передают адрес этой переменной. Раньше мы передавали значения, и функция могла менять только свою копию. Теперь разберём, почему так, и как три уже знакомые вещи на самом деле объясняются одним приёмом: swap, scanf и функции с несколькими результатами. Основа — указатели.
Что пригодится из прошлого: свои функции, указатели, сортировка по функциям. Если эти темы знакомы, читайте дальше. Если нет — загляните по ссылке, потом возвращайтесь.
Параметр — это копия
Напишем функцию, которая меняет два числа местами, и вызовем её в самом очевидном виде. Полная программа:
#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 ← меняются только эти копии
Как передать не копию, а место
Если вместо значения передать адрес, копия адреса всё равно ведёт в ту же самую переменную. Как две записки с одним и тем же адресом дома: сколько ни копируй записку, дом остаётся один.
Полная программа:
#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]:
#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 его передают без &:
#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 возвращает одно значение. Если результатов два, функции передают адреса «пустых коробок», куда она сама положит ответы. Например, частное и остаток:
#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. Проверим это программой. В ней две функции одинаково считают сумму, но параметр записан по-разному:
#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. - Массив передаётся по адресу первого элемента, поэтому функция может менять его элементы.
