5.3. Массивы и строки как параметры функций

Теория

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

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

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

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

Как массив передаётся в функцию

Если функция принимает массив, внутрь функции передаётся не весь массив, а адрес его первого элемента.

void printArray(int a[], int n)

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

int numbers[5] = { 1, 2, 3, 4, 5 };

printArray(numbers, 5);

При вызове printArray(numbers, 5) в функцию передаётся адрес numbers[0]. Поэтому внутри функции можно обращаться к элементам так:

a[0]
a[1]
a[2]

Но эти элементы — не копии. Это элементы исходного массива.

Две формы записи параметра-массива

В параметрах функции записи с массивом и указателем часто эквивалентны.

void printArray(int a[], int n)

То же самое можно записать так:

void printArray(int *a, int n)

Оба варианта означают, что функция получает адрес первого элемента массива типа int.

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

float scalarProduct(int n, float a[], float b[]);
float scalarProduct(int n, float *a, float *b);

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

Почему размер массива передают отдельно

Когда массив передаётся в функцию, функция получает только адрес первого элемента. Она не узнаёт автоматически, сколько элементов находится в массиве.

void printArray(int a[])

Такой функции не хватает информации: она знает, где начинается массив, но не знает, где он заканчивается.

Поэтому обычно размер передают отдельным параметром:

void printArray(int a[], int n)

Здесь:

Пример: вывод массива

#include <stdio.h>

void printArray(int a[], int n);

int main(void)
{
    int numbers[5] = { 10, 20, 30, 40, 50 };

    printArray(numbers, 5);

    return 0;
}

void printArray(int a[], int n)
{
    int i;

    for (i = 0; i < n; i++)
    {
        printf("%d ", a[i]);
    }

    printf("\n");
}

Функция printArray получает адрес первого элемента массива и количество элементов. Затем она проходит по массиву от индекса 0 до n - 1.

То же самое через указатель

Эту же функцию можно записать через параметр-указатель.

#include <stdio.h>

void printArray(int *a, int n);

int main(void)
{
    int numbers[5] = { 10, 20, 30, 40, 50 };

    printArray(numbers, 5);

    return 0;
}

void printArray(int *a, int n)
{
    int i;

    for (i = 0; i < n; i++)
    {
        printf("%d ", a[i]);
    }

    printf("\n");
}

Внутри функции можно всё равно использовать индексную запись a[i]. Указатель на первый элемент массива позволяет обращаться к элементам так же, как к элементам массива.

Индексная и указательная формы доступа

Если a — параметр-массив или параметр-указатель, то доступ к элементу можно записать двумя способами.

a[i]

или:

*(a + i)

Эти записи эквивалентны.

printf("%d\n", a[i]);
printf("%d\n", *(a + i));

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

Функция может изменить элементы массива

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

#include <stdio.h>

void squareArray(int a[], int n);

int main(void)
{
    int numbers[5] = { 1, 2, 3, 4, 5 };
    int i;

    squareArray(numbers, 5);

    for (i = 0; i < 5; i++)
    {
        printf("%d ", numbers[i]);
    }

    printf("\n");

    return 0;
}

void squareArray(int a[], int n)
{
    int i;

    for (i = 0; i < n; i++)
    {
        a[i] = a[i] * a[i];
    }
}

После вызова squareArray(numbers, 5) массив numbers изменится:

1 4 9 16 25

Это отличается от обычных параметров типа int, которые передаются по значению и не изменяют исходную переменную.

Пример из книги: возведение элементов в квадрат

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

#include <stdio.h>

void quart(int n, float *x);

int main(void)
{
    float z[] = { 1.0, 2.0, 3.0, 4.0 };
    int j;

    quart(4, z);

    for (j = 0; j < 4; j++)
    {
        printf("z[%d] = %f\n", j, z[j]);
    }

    return 0;
}

void quart(int n, float *x)
{
    int i;

    for (i = 0; i < n; i++)
    {
        *(x + i) *= *(x + i);
    }
}

Выражение:

*(x + i)

означает элемент массива с индексом i. Поэтому строка:

*(x + i) *= *(x + i);

возводит текущий элемент массива в квадрат.

Можно ли менять сам параметр-массив внутри функции

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

void printArray(int *a, int n)
{
    int i;

    for (i = 0; i < n; i++)
    {
        printf("%d ", *a);
        a++;
    }
}

Здесь a++ передвигает локальный указатель на следующий элемент массива.

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

Имя массива в main изменить нельзя

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

int z[4] = { 1, 2, 3, 4 };

z++;      /* ошибка */
z = NULL; /* ошибка */

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

А вот параметр функции:

void function(int z[])

внутри функции работает как указатель. Его можно изменять:

z++;

Поэтому важно различать:

Опасная запись с двумя инкрементами

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

Например, если нужно возвести текущий элемент в квадрат и перейти к следующему элементу, можно написать проще и безопаснее:

*x = *x * *x;
x++;

Или компактнее:

*x *= *x;
x++;

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

*x++ *= *x++;  /* ошибка по смыслу */

Такая запись трудна для чтения и приводит к неправильному переходу по массиву. Указатель изменяется больше одного раза, поэтому элементы могут пропускаться, а поведение становится непонятным.

Функция суммы элементов массива

#include <stdio.h>

int arraySum(const int a[], int n);

int main(void)
{
    int numbers[5] = { 4, 7, 1, 9, 3 };
    int sum;

    sum = arraySum(numbers, 5);

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

    return 0;
}

int arraySum(const int a[], int n)
{
    int i;
    int sum = 0;

    for (i = 0; i < n; i++)
    {
        sum += a[i];
    }

    return sum;
}

Здесь параметр записан как const int a[]. Это означает, что функция не должна изменять элементы массива.

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

const для массивов-параметров

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

void printArray(const int a[], int n);
int arrayMax(const int a[], int n);
int arraySum(const int a[], int n);

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

void printArray(const int a[], int n)
{
    a[0] = 100;  /* ошибка */
}

Это помогает защитить данные от случайного изменения и делает назначение функции понятнее.

Функция поиска максимума

#include <stdio.h>

int arrayMax(const int a[], int n);

int main(void)
{
    int numbers[5] = { 4, 7, 1, 9, 3 };

    printf("max = %d\n", arrayMax(numbers, 5));

    return 0;
}

int arrayMax(const int a[], int n)
{
    int i;
    int max;

    max = a[0];

    for (i = 1; i < n; i++)
    {
        if (a[i] > max)
        {
            max = a[i];
        }
    }

    return max;
}

Функция предполагает, что n > 0. Если массив может быть пустым, нужно отдельно продумать, что функция должна возвращать или как она должна сообщать об ошибке.

Безопасная версия с проверкой

Можно возвращать признак успешности через return, а максимум записывать через параметр-указатель.

#include <stdio.h>

int arrayMax(const int a[], int n, int *result);

int main(void)
{
    int numbers[5] = { 4, 7, 1, 9, 3 };
    int maxValue;

    if (arrayMax(numbers, 5, &maxValue))
    {
        printf("max = %d\n", maxValue);
    }
    else
    {
        printf("Ошибка поиска максимума\n");
    }

    return 0;
}

int arrayMax(const int a[], int n, int *result)
{
    int i;
    int max;

    if (a == NULL || result == NULL || n <= 0)
    {
        return 0;
    }

    max = a[0];

    for (i = 1; i < n; i++)
    {
        if (a[i] > max)
        {
            max = a[i];
        }
    }

    *result = max;

    return 1;
}

Такая функция проверяет входные данные и не разыменовывает неправильные указатели.

Скалярное произведение массивов

Массивы в параметрах удобно использовать для математических задач. Например, скалярное произведение двух векторов:

#include <stdio.h>

float scalarProduct(int n, const float a[], const float b[]);

int main(void)
{
    float x[3] = { 1.0f, 2.0f, 3.0f };
    float y[3] = { 4.0f, 5.0f, 6.0f };

    printf("result = %f\n", scalarProduct(3, x, y));

    return 0;
}

float scalarProduct(int n, const float a[], const float b[])
{
    int i;
    float result = 0.0f;

    for (i = 0; i < n; i++)
    {
        result += a[i] * b[i];
    }

    return result;
}

Так как функция только читает элементы массивов, параметры a и b объявлены с const.

sizeof внутри функции с массивом

Внутри функции параметр-массив фактически является указателем. Поэтому sizeof внутри функции не покажет размер исходного массива.

#include <stdio.h>

void showSize(int a[]);

int main(void)
{
    int numbers[10];

    printf("sizeof in main = %zu\n", sizeof(numbers));

    showSize(numbers);

    return 0;
}

void showSize(int a[])
{
    printf("sizeof in function = %zu\n", sizeof(a));
}

В main выражение sizeof(numbers) даёт размер всего массива. В функции sizeof(a) даёт размер указателя.

Поэтому количество элементов нужно передавать отдельно.

Передача двумерного массива в функцию

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

void printMatrix(int rows, int cols, int matrix[rows][cols]);

В современном C можно использовать параметры rows и cols для задания размеров.

#include <stdio.h>

void printMatrix(int rows, int cols, int matrix[rows][cols]);

int main(void)
{
    int a[2][3] = {
        { 1, 2, 3 },
        { 4, 5, 6 }
    };

    printMatrix(2, 3, a);

    return 0;
}

void printMatrix(int rows, int cols, int matrix[rows][cols])
{
    int i;
    int j;

    for (i = 0; i < rows; i++)
    {
        for (j = 0; j < cols; j++)
        {
            printf("%4d", matrix[i][j]);
        }

        printf("\n");
    }
}

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

Двумерный массив с фиксированным числом столбцов

#include <stdio.h>

#define COLS 3

void printMatrix(int matrix[][COLS], int rows);

int main(void)
{
    int a[2][COLS] = {
        { 1, 2, 3 },
        { 4, 5, 6 }
    };

    printMatrix(a, 2);

    return 0;
}

void printMatrix(int matrix[][COLS], int rows)
{
    int i;
    int j;

    for (i = 0; i < rows; i++)
    {
        for (j = 0; j < COLS; j++)
        {
            printf("%4d", matrix[i][j]);
        }

        printf("\n");
    }
}

Для двумерного массива компилятору нужно знать размер строки, чтобы правильно вычислять адрес элемента matrix[i][j].

Строки как параметры функций

Строка в C — это массив символов char, который заканчивается нулевым символом '\0'.

Поэтому строку можно передать в функцию как массив:

int length(char s[]);

или как указатель:

int length(char *s);

В обоих случаях функция получает адрес первого символа строки.

char text[] = "Hello";

length(text);

В функцию передаётся адрес символа text[0].

Почему строкам часто не передают длину

Обычному массиву чисел нужно отдельно передавать количество элементов.

arraySum(a, n);

А строка содержит специальный завершающий символ '\0'. Он показывает, где строка заканчивается.

H e l l o \0

Поэтому функция может идти по строке до тех пор, пока не встретит '\0'.

while (s[i] != '\0')
{
    i++;
}

Но это работает только для корректных C-строк. Если в массиве символов нет '\0', строковая функция может выйти за границы массива.

Функция вычисления длины строки через индексы

#include <stdio.h>

int stringLength(char s[]);

int main(void)
{
    char text[] = "Hello";

    printf("length = %d\n", stringLength(text));

    return 0;
}

int stringLength(char s[])
{
    int i;

    for (i = 0; s[i] != '\0'; i++)
    {
    }

    return i;
}

Цикл увеличивает i, пока не встретит нулевой символ. Когда найден '\0', значение i равно длине строки.

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

#include <stdio.h>

int stringLength(char *s);

int main(void)
{
    char text[] = "Hello";

    printf("length = %d\n", stringLength(text));

    return 0;
}

int stringLength(char *s)
{
    int length = 0;

    while (*s != '\0')
    {
        length++;
        s++;
    }

    return length;
}

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

Когда *s становится равным '\0', цикл завершается.

Строка только для чтения

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

int stringLength(const char *s);

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

int stringLength(const char *s)
{
    int length = 0;

    while (*s != '\0')
    {
        length++;
        s++;
    }

    return length;
}

Теперь внутри функции нельзя случайно написать:

*s = 'A';  /* ошибка */

Функция инвертирования строки

Функция может не только читать строку, но и изменять её. Например, можно развернуть строку наоборот.

#include <stdio.h>

void invert(char s[]);

int main(void)
{
    char text[] = "syrup";

    invert(text);

    printf("%s\n", text);

    return 0;
}

void invert(char s[])
{
    int i;
    int j;
    int length;
    char temp;

    for (length = 0; s[length] != '\0'; length++)
    {
    }

    for (i = 0, j = length - 1; i < j; i++, j--)
    {
        temp = s[i];
        s[i] = s[j];
        s[j] = temp;
    }
}

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

Нулевой символ '\0' остаётся в конце строки.

Инвертирование строки через два указателя

#include <stdio.h>

void invert(char *s);

int main(void)
{
    char text[] = "hello";

    invert(text);

    printf("%s\n", text);

    return 0;
}

void invert(char *s)
{
    char *left;
    char *right;
    char temp;

    if (s == NULL)
    {
        return;
    }

    left = s;
    right = s;

    while (*right != '\0')
    {
        right++;
    }

    right--;

    while (left < right)
    {
        temp = *left;
        *left = *right;
        *right = temp;

        left++;
        right--;
    }
}

Здесь left сначала указывает на первый символ строки, а right после поиска конца строки сдвигается на последний обычный символ перед '\0'.

Функция подсчёта символа в строке

#include <stdio.h>

int countChar(const char *s, char target);

int main(void)
{
    char text[] = "banana";

    printf("count = %d\n", countChar(text, 'a'));

    return 0;
}

int countChar(const char *s, char target)
{
    int count = 0;

    if (s == NULL)
    {
        return 0;
    }

    while (*s != '\0')
    {
        if (*s == target)
        {
            count++;
        }

        s++;
    }

    return count;
}

Функция получает строку только для чтения, поэтому используется const char *. Символы просматриваются до нулевого терминатора.

Функция копирования строки

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

#include <stdio.h>

void copyString(char destination[], const char source[]);

int main(void)
{
    char source[] = "Hello";
    char destination[20];

    copyString(destination, source);

    printf("%s\n", destination);

    return 0;
}

void copyString(char destination[], const char source[])
{
    int i = 0;

    while (source[i] != '\0')
    {
        destination[i] = source[i];
        i++;
    }

    destination[i] = '\0';
}

После копирования обычных символов функция обязательно записывает завершающий нулевой символ.

Безопаснее передавать размер буфера

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

#include <stdio.h>

int copyString(char destination[], int destinationSize, const char source[]);

int main(void)
{
    char source[] = "Hello";
    char destination[20];

    if (copyString(destination, 20, source))
    {
        printf("%s\n", destination);
    }
    else
    {
        printf("Ошибка копирования\n");
    }

    return 0;
}

int copyString(char destination[], int destinationSize, const char source[])
{
    int i = 0;

    if (destination == NULL || source == NULL || destinationSize <= 0)
    {
        return 0;
    }

    while (source[i] != '\0' && i < destinationSize - 1)
    {
        destination[i] = source[i];
        i++;
    }

    destination[i] = '\0';

    if (source[i] != '\0')
    {
        return 0;
    }

    return 1;
}

Такая функция не выходит за пределы массива назначения. Она оставляет место под '\0' и сообщает об ошибке, если исходная строка не поместилась полностью.

Массив строк как параметр

Массив строк часто передают как массив указателей на char.

#include <stdio.h>

void printWords(const char *words[], int count);

int main(void)
{
    const char *colors[] = {
        "red",
        "green",
        "blue"
    };

    printWords(colors, 3);

    return 0;
}

void printWords(const char *words[], int count)
{
    int i;

    for (i = 0; i < count; i++)
    {
        printf("%s\n", words[i]);
    }
}

Здесь words — массив указателей на строки. Каждый элемент words[i] указывает на начало отдельной строки.

Изменяемые строки одинаковой длины

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

#include <stdio.h>

#define WORD_SIZE 20

void printWords(char words[][WORD_SIZE], int count);

int main(void)
{
    char words[3][WORD_SIZE] = {
        "red",
        "green",
        "blue"
    };

    printWords(words, 3);

    return 0;
}

void printWords(char words[][WORD_SIZE], int count)
{
    int i;

    for (i = 0; i < count; i++)
    {
        printf("%s\n", words[i]);
    }
}

Здесь каждая строка занимает WORD_SIZE элементов. Компилятору нужно знать этот размер, чтобы правильно переходить от одной строки к другой.

Когда использовать char[] и когда char *

Запись параметра Когда удобно использовать
char s[] когда хочется подчеркнуть, что функция работает со строкой как с массивом символов
char *s когда важно явно показать указательную природу параметра
const char *s когда функция только читает строку и не должна её изменять
char s[][20] когда передаётся двумерный массив изменяемых строк одинакового размера
const char *s[] когда передаётся массив указателей на строки

Строковый литерал и изменяемая строка

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

void invert(char s[]);

invert("hello");  /* ошибка по смыслу */

Строковый литерал изменять нельзя. Нужно создать изменяемый массив:

char text[] = "hello";

invert(text);

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

int stringLength(const char *s);

printf("%d\n", stringLength("hello"));

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

Ошибка 1. Ожидание, что массив копируется в функцию

void change(int a[], int n)
{
    a[0] = 100;
}

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

Ошибка 2. Не передали размер обычного массива

void printArray(int a[])
{
    /* неизвестно, сколько элементов печатать */
}

Правильно передавать размер:

void printArray(int a[], int n)

Ошибка 3. Использование sizeof для параметра-массива

void f(int a[])
{
    int n = sizeof(a) / sizeof(a[0]);  /* ошибка по смыслу */
}

В функции a — указатель, а не настоящий массив.

Ошибка 4. Попытка изменить имя настоящего массива

int a[5];

a++;  /* ошибка */

Имя настоящего массива нельзя передвинуть. Но параметр-указатель внутри функции можно изменять.

Ошибка 5. Выход за границы массива

for (i = 0; i <= n; i++)
{
    printf("%d\n", a[i]);
}

Если в массиве n элементов, допустимые индексы: от 0 до n - 1.

Ошибка 6. Передача строки без '\0'

char text[5] = { 'H', 'e', 'l', 'l', 'o' };

stringLength(text);  /* опасно */

Это массив символов, но не корректная C-строка, потому что нет завершающего '\0'.

Ошибка 7. Изменение строкового литерала

void invert(char s[]);

invert("hello");  /* нельзя изменять строковый литерал */

Для изменения нужна строка в массиве:

char text[] = "hello";
invert(text);

Ошибка 8. Не оставили место под '\0'

char destination[5];

copyString(destination, 5, "Hello");

Для строки "Hello" нужно 6 элементов: 5 букв и завершающий '\0'.

Ошибка 9. Не проверили указатель на NULL

int stringLength(char *s)
{
    while (*s != '\0')
    {
        s++;
    }
}

Если s может быть равен NULL, перед разыменованием нужна проверка.

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

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

Программа вводит строку, считает её длину собственной функцией, считает количество заданного символа и разворачивает строку.

#include <stdio.h>
#include <string.h>

int stringLength(const char *s);
int countChar(const char *s, char target);
void invert(char s[]);

int main(void)
{
    char text[100];
    char target;
    int len;
    int count;

    printf("Введите строку: ");

    if (fgets(text, sizeof(text), stdin) == NULL)
    {
        printf("Ошибка ввода\n");
        return 0;
    }

    len = stringLength(text);

    if (len > 0 && text[len - 1] == '\n')
    {
        text[len - 1] = '\0';
    }

    printf("Введите символ для поиска: ");
    scanf(" %c", &target);

    len = stringLength(text);
    count = countChar(text, target);

    printf("Длина строки = %d\n", len);
    printf("Количество символов '%c' = %d\n", target, count);

    invert(text);

    printf("Строка наоборот: %s\n", text);

    return 0;
}

int stringLength(const char *s)
{
    int length = 0;

    if (s == NULL)
    {
        return 0;
    }

    while (*s != '\0')
    {
        length++;
        s++;
    }

    return length;
}

int countChar(const char *s, char target)
{
    int count = 0;

    if (s == NULL)
    {
        return 0;
    }

    while (*s != '\0')
    {
        if (*s == target)
        {
            count++;
        }

        s++;
    }

    return count;
}

void invert(char s[])
{
    int left;
    int right;
    char temp;

    if (s == NULL)
    {
        return;
    }

    left = 0;
    right = stringLength(s) - 1;

    while (left < right)
    {
        temp = s[left];
        s[left] = s[right];
        s[right] = temp;

        left++;
        right--;
    }
}

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

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

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

  1. Что на самом деле передаётся в функцию при передаче массива?
  2. Почему параметр int a[] близок по смыслу к int *a?
  3. Почему размер массива нужно передавать отдельным параметром?
  4. Может ли функция изменить элементы массива, переданного ей как параметр?
  5. Чему эквивалентна запись a[i]?
  6. Чем отличается имя массива в main от параметра-массива в функции?
  7. Почему внутри функции можно написать a++, если a — параметр?
  8. Почему нельзя написать z++, если z — настоящий массив?
  9. Для чего используется const в параметре-массиве?
  10. Почему sizeof(a) внутри функции не даёт размер исходного массива?
  11. Как строка передаётся в функцию?
  12. Почему для строки часто не передают длину отдельно?
  13. Что произойдёт, если строка не содержит '\0'?
  14. Почему нельзя передавать строковый литерал в функцию, которая изменяет строку?
  15. Как функция может вернуть результат обработки массива через обычный return?
  16. Как функция может изменить строку, переданную ей как параметр?
  17. Почему для двумерного массива нужно знать количество столбцов?