5.2. Указатели в параметрах функций

Теория

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

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

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

Для этого в параметры функции передают не само значение переменной, а её адрес. Такой параметр называется параметром-указателем.

Проблема передачи по значению

Рассмотрим функцию, которая пытается изменить значение переменной.

#include <stdio.h>

void change(int x)
{
    x = 100;
}

int main(void)
{
    int a = 10;

    change(a);

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

    return 0;
}

Результат:

a = 10

Переменная a не изменилась. Почему?

При вызове change(a) функция получает копию значения переменной a. Внутри функции эта копия называется x. Когда выполняется x = 100;, меняется только локальный параметр x, а исходная переменная a остаётся прежней.

Идея передачи адреса

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

int a = 10;

change(&a);

Выражение &a означает адрес переменной a. Если функция получит этот адрес, она сможет обратиться к переменной через указатель.

Тогда параметр функции должен быть указателем:

void change(int *p)

Здесь p — указатель на int. Он может хранить адрес переменной типа int.

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

#include <stdio.h>

void change(int *p)
{
    *p = 100;
}

int main(void)
{
    int a = 10;

    change(&a);

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

    return 0;
}

Результат:

a = 100

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

  1. a — обычная переменная типа int;
  2. &a — адрес переменной a;
  3. change(&a) передаёт этот адрес в функцию;
  4. p получает адрес переменной a;
  5. *p = 100; записывает число 100 в объект по адресу p;
  6. так как p указывает на a, изменяется именно a.

Параметр-указатель

Параметр-указатель — это параметр функции, который хранит адрес объекта.

void function(int *p)

Здесь p — не обычный int, а указатель на int.

Внутри функции:

void setZero(int *p)
{
    *p = 0;
}

Эта функция записывает 0 в переменную, адрес которой был передан в функцию.

Аргумент для параметра-указателя

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

void setZero(int *p);

int x = 5;

setZero(&x);

Нельзя передать просто x, если функция ожидает int *.

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

setZero(x);

Правильно:

setZero(&x);

То есть нужно внимательно смотреть на тип параметра:

Параметр функции Что передавать
int x значение типа int
int *p адрес переменной типа int
double *p адрес переменной типа double
char *p адрес переменной типа char

Пример: обнуление переменной

#include <stdio.h>

void reset(int *value);

int main(void)
{
    int number = 45;

    printf("До вызова: %d\n", number);

    reset(&number);

    printf("После вызова: %d\n", number);

    return 0;
}

void reset(int *value)
{
    *value = 0;
}

Вызов reset(&number) передаёт в функцию адрес переменной number. Внутри функции запись *value = 0; изменяет эту переменную.

Пример: увеличение значения через указатель

#include <stdio.h>

void increase(int *value);

int main(void)
{
    int x = 10;

    increase(&x);

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

    return 0;
}

void increase(int *value)
{
    *value = *value + 1;
}

Строка:

*value = *value + 1;

означает: взять значение объекта по адресу value, увеличить его на 1 и записать обратно по тому же адресу.

Обмен значений двух переменных

Классический пример использования указателей в параметрах — функция обмена значений.

#include <stdio.h>

void swap(int *a, int *b);

int main(void)
{
    int x = 10;
    int y = 20;

    printf("До обмена: x = %d, y = %d\n", x, y);

    swap(&x, &y);

    printf("После обмена: x = %d, y = %d\n", x, y);

    return 0;
}

void swap(int *a, int *b)
{
    int temp;

    temp = *a;
    *a = *b;
    *b = temp;
}

Результат:

До обмена: x = 10, y = 20
После обмена: x = 20, y = 10

Функция получает адреса переменных x и y. Поэтому внутри функции можно изменить сами переменные, а не только их локальные копии.

Почему обычный swap не работает

Если написать функцию обмена без указателей, она не изменит исходные переменные.

void badSwap(int a, int b)
{
    int temp;

    temp = a;
    a = b;
    b = temp;
}

При вызове:

badSwap(x, y);

функция получает копии значений x и y. Она меняет местами только свои локальные параметры a и b. Переменные x и y в main не меняются.

Поэтому для настоящего обмена значений нужны адреса:

swap(&x, &y);

Функция может возвращать только одно значение через return

Оператор return возвращает из функции одно значение.

int sum(int a, int b)
{
    return a + b;
}

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

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

Пример: сумма и произведение через параметры-указатели

#include <stdio.h>

void calculate(int a, int b, int *sum, int *product);

int main(void)
{
    int x = 4;
    int y = 5;
    int s;
    int p;

    calculate(x, y, &s, &p);

    printf("sum = %d\n", s);
    printf("product = %d\n", p);

    return 0;
}

void calculate(int a, int b, int *sum, int *product)
{
    *sum = a + b;
    *product = a * b;
}

Здесь a и b передаются обычным способом, потому что их не нужно менять.

А sum и product являются указателями, потому что функция должна записать в них результаты.

Входные и выходные параметры

Параметры функции можно условно разделить на входные и выходные.

void calculate(int a, int b, int *sum, int *product)

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

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

Часто указатели в параметрах именно так и используются: они дают функции место, куда нужно записать результат.

Возврат статуса и результатов через указатели

Хороший приём: через return возвращать статус выполнения, а настоящие вычисленные значения записывать через параметры-указатели.

Например, деление может быть невозможно, если делитель равен нулю.

#include <stdio.h>

int divide(int a, int b, int *quotient, int *remainder);

int main(void)
{
    int a = 17;
    int b = 5;
    int q;
    int r;

    if (divide(a, b, &q, &r))
    {
        printf("quotient = %d\n", q);
        printf("remainder = %d\n", r);
    }
    else
    {
        printf("Ошибка: деление на ноль\n");
    }

    return 0;
}

int divide(int a, int b, int *quotient, int *remainder)
{
    if (b == 0)
    {
        return 0;
    }

    *quotient = a / b;
    *remainder = a % b;

    return 1;
}

Здесь функция возвращает:

А частное и остаток записываются в переменные q и r через указатели.

Пример: минимум и максимум

Функция может найти минимум и максимум из двух чисел и вернуть оба результата через указатели.

#include <stdio.h>

void minMax(int a, int b, int *minValue, int *maxValue);

int main(void)
{
    int x = 30;
    int y = 12;
    int minResult;
    int maxResult;

    minMax(x, y, &minResult, &maxResult);

    printf("min = %d\n", minResult);
    printf("max = %d\n", maxResult);

    return 0;
}

void minMax(int a, int b, int *minValue, int *maxValue)
{
    if (a < b)
    {
        *minValue = a;
        *maxValue = b;
    }
    else
    {
        *minValue = b;
        *maxValue = a;
    }
}

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

Пример: периметр и площадь треугольника

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

#include <stdio.h>
#include <math.h>

int triangle(double a, double b, double c, double *perimeter, double *area);

int main(void)
{
    double x;
    double y;
    double z;
    double p;
    double s;

    printf("Введите стороны треугольника: ");
    scanf("%lf%lf%lf", &x, &y, &z);

    if (triangle(x, y, z, &p, &s))
    {
        printf("Периметр = %.2f\n", p);
        printf("Площадь = %.2f\n", s);
    }
    else
    {
        printf("Ошибка: такого треугольника не существует\n");
    }

    return 0;
}

int triangle(double a, double b, double c, double *perimeter, double *area)
{
    double half;

    if (a <= 0 || b <= 0 || c <= 0)
    {
        return 0;
    }

    if (a + b <= c || a + c <= b || b + c <= a)
    {
        return 0;
    }

    *perimeter = a + b + c;

    half = *perimeter / 2.0;

    *area = sqrt(half * (half - a) * (half - b) * (half - c));

    return 1;
}

Здесь функция triangle возвращает статус:

Периметр и площадь возвращаются не через return, а через параметры perimeter и area.

Почему параметры-указатели всё равно передаются по значению

Важно понимать: даже указатели в C передаются в функцию по значению. То есть функция получает копию адреса.

void changePointer(int *p)
{
    p = NULL;
}

Если вызвать такую функцию:

int x = 10;
int *ptr = &x;

changePointer(ptr);

переменная ptr в main не станет равной NULL. Функция изменила только свою локальную копию указателя p.

Но если функция разыменовывает указатель:

*p = 100;

она изменяет объект по переданному адресу. Поэтому исходная переменная может измениться.

Изменение указателя вызывающей функции

Если нужно изменить сам указатель вызывающей функции, нужно передать адрес этого указателя. То есть нужен указатель на указатель.

#include <stdio.h>

void setToNull(int **p);

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

    setToNull(&ptr);

    if (ptr == NULL)
    {
        printf("ptr теперь равен NULL\n");
    }

    return 0;
}

void setToNull(int **p)
{
    *p = NULL;
}

Здесь:

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

Проверка указателя на NULL

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

void setZero(int *p)
{
    if (p == NULL)
    {
        return;
    }

    *p = 0;
}

Это защищает функцию от разыменования нулевого указателя.

Разыменовывать NULL нельзя:

int *p = NULL;

*p = 10;  /* ошибка */

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

Защитная версия функции swap

void swap(int *a, int *b)
{
    int temp;

    if (a == NULL || b == NULL)
    {
        return;
    }

    temp = *a;
    *a = *b;
    *b = temp;
}

Такая функция сначала проверяет, что оба указателя действительно указывают на объекты. Если один из указателей равен NULL, функция просто завершает работу.

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

const в параметрах-указателях

Если функция получает адрес объекта, но не должна изменять сам объект, можно использовать const.

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

Запись const int *p означает: через указатель p нельзя изменить значение объекта.

Нельзя:

void printValue(const int *p)
{
    *p = 10;  /* ошибка */
}

Такой приём полезен для входных параметров-указателей: функция получает адрес для чтения, но не имеет права менять данные.

Когда использовать обычный параметр, а когда указатель

Задача Что использовать
функции нужно только прочитать небольшое значение обычный параметр
функция должна изменить переменную вызывающей функции параметр-указатель
функция должна вернуть несколько результатов return для статуса + параметры-указатели для результатов
функция получает адрес, но не должна менять объект указатель на const
функция должна изменить сам указатель указатель на указатель

Параметры-указатели и scanf

С передачей адреса в функцию мы уже сталкивались при работе со scanf.

int x;

scanf("%d", &x);

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

&x

По сути, scanf использует тот же принцип, что и наши функции с параметрами-указателями: получает адрес и записывает значение по этому адресу.

Небольшая собственная функция ввода

Можно написать функцию, которая вводит число в переменную, адрес которой ей передали.

#include <stdio.h>

int readInt(int *value);

int main(void)
{
    int number;

    if (readInt(&number))
    {
        printf("number = %d\n", number);
    }
    else
    {
        printf("Ошибка ввода\n");
    }

    return 0;
}

int readInt(int *value)
{
    if (value == NULL)
    {
        return 0;
    }

    printf("Введите число: ");

    if (scanf("%d", value) != 1)
    {
        return 0;
    }

    return 1;
}

Здесь value уже является адресом переменной, поэтому в вызове scanf не нужно писать &value.

Это важный момент:

scanf("%d", value);

потому что value уже имеет тип int *.

Частая путаница: value и &value

Если есть обычная переменная:

int x;

в scanf передаётся её адрес:

scanf("%d", &x);

Если есть параметр-указатель:

int *value;

сам value уже хранит адрес:

scanf("%d", value);

А &value — это адрес самого указателя, то есть другой тип: указатель на указатель.

&value  /* тип int ** */

Параметр-указатель как выходной параметр

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

int getSquare(int x, int *result)
{
    if (result == NULL)
    {
        return 0;
    }

    *result = x * x;

    return 1;
}

Вызов:

int answer;

getSquare(7, &answer);

После вызова в переменной answer будет лежать результат.

Функция с несколькими выходными параметрами

У функции может быть несколько параметров-указателей.

#include <stdio.h>

int splitNumber(int number, int *tens, int *ones);

int main(void)
{
    int number = 47;
    int t;
    int o;

    if (splitNumber(number, &t, &o))
    {
        printf("tens = %d\n", t);
        printf("ones = %d\n", o);
    }

    return 0;
}

int splitNumber(int number, int *tens, int *ones)
{
    if (number < 0 || number > 99)
    {
        return 0;
    }

    if (tens == NULL || ones == NULL)
    {
        return 0;
    }

    *tens = number / 10;
    *ones = number % 10;

    return 1;
}

Функция возвращает 0, если данные некорректны, и 1, если результат успешно записан.

Указатель в параметре не обязан называться p

Имена параметров-указателей нужно выбирать по смыслу.

void reset(int *value);
void swap(int *left, int *right);
int triangle(double a, double b, double c, double *perimeter, double *area);

Плохие имена:

void f(int *p1, int *p2, int *p3);

Лучше:

void calculateStats(int value, int *minValue, int *maxValue);

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

Указатели и область видимости

Указатель может хранить адрес переменной из другой функции, но нужно помнить о времени жизни этой переменной.

Если переменная существует в main, а её адрес передаётся в функцию, всё нормально:

int main(void)
{
    int x = 10;

    change(&x);

    return 0;
}

Переменная x существует всё время, пока выполняется main.

Но нельзя возвращать из функции адрес её локальной переменной:

int *badFunction(void)
{
    int local = 10;

    return &local;  /* ошибка */
}

После завершения функции local исчезает. Возвращённый адрес будет указывать на объект, которого уже нет.

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

Ошибка 1. Передали значение вместо адреса

void change(int *p);

int x = 10;

change(x);   /* ошибка */

Функция ждёт адрес, поэтому нужно:

change(&x);

Ошибка 2. Забыли разыменование внутри функции

void change(int *p)
{
    p = 100;  /* ошибка */
}

p — это адрес. Чтобы изменить объект по адресу, нужно:

*p = 100;

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

void change(int *p)
{
    *p = 100;
}

change(NULL);

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

Ошибка 4. Использование & там, где уже есть указатель

int readInt(int *value)
{
    scanf("%d", &value);  /* ошибка */
}

value уже является адресом переменной типа int. Поэтому правильно:

scanf("%d", value);

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

void changeDouble(double *p);

int x = 10;

changeDouble(&x);  /* ошибка типа */

Адрес int нельзя передавать туда, где ожидается double *.

Ошибка 6. Ожидание, что изменение указателя изменит указатель снаружи

void setNull(int *p)
{
    p = NULL;
}

Эта функция изменяет только локальную копию указателя. Чтобы изменить сам указатель вызывающей функции, нужен указатель на указатель.

Ошибка 7. Возврат адреса локальной переменной

int *bad(void)
{
    int x = 10;
    return &x;
}

После завершения функции переменная x перестаёт существовать.

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

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

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

#include <stdio.h>

void swap(int *a, int *b);
int calculate(int a, int b, int *sum, int *product);

int main(void)
{
    int x;
    int y;
    int s;
    int p;

    printf("Введите два числа: ");
    scanf("%d%d", &x, &y);

    printf("До обмена: x = %d, y = %d\n", x, y);

    swap(&x, &y);

    printf("После обмена: x = %d, y = %d\n", x, y);

    if (calculate(x, y, &s, &p))
    {
        printf("sum = %d\n", s);
        printf("product = %d\n", p);
    }
    else
    {
        printf("Ошибка вычисления\n");
    }

    return 0;
}

void swap(int *a, int *b)
{
    int temp;

    if (a == NULL || b == NULL)
    {
        return;
    }

    temp = *a;
    *a = *b;
    *b = temp;
}

int calculate(int a, int b, int *sum, int *product)
{
    if (sum == NULL || product == NULL)
    {
        return 0;
    }

    *sum = a + b;
    *product = a * b;

    return 1;
}

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

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

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

  1. Почему обычная функция change(int x) не меняет переменную вызывающей функции?
  2. Что нужно передать в функцию, чтобы она могла изменить переменную?
  3. Что означает параметр int *p?
  4. Чем отличается p от *p внутри функции?
  5. Почему при вызове пишут change(&x), а не change(x)?
  6. Как работает функция обмена значений через указатели?
  7. Почему функция badSwap(int a, int b) не меняет исходные переменные?
  8. Как вернуть из функции два результата?
  9. Почему удобно возвращать статус через return, а данные через параметры-указатели?
  10. Что произойдёт при разыменовании NULL?
  11. Зачем проверять параметры-указатели на NULL?
  12. Что означает const int *p?
  13. Почему сами указатели тоже передаются по значению?
  14. Когда нужен указатель на указатель?
  15. Почему нельзя возвращать адрес локальной переменной?