5.3. Массивы и строки как параметры функций
Теория
Зачем нужен этот пункт
Массивы и строки часто передаются в функции. Например, функция может вывести массив, найти сумму элементов, изменить все элементы, найти символ в строке или развернуть строку.
В языке C массив не передаётся в функцию целиком как копия. Вместо этого в функцию передаётся адрес начала массива. Поэтому функция получает доступ к тем же самым элементам, которые находятся в вызывающей программе.
В этом пункте рассматриваются:
- как массив передаётся в функцию;
- почему
int a[]иint *aв параметрах похожи; - почему размер массива нужно передавать отдельно;
- как функция может изменить элементы массива;
- как обходить массив через индексы и через указатель;
- чем отличается имя массива в
mainот параметра-массива в функции; - как строки передаются в функции;
- почему строкам обычно не нужен отдельный параметр длины;
- как написать собственные функции для обработки строк.
Как массив передаётся в функцию
Если функция принимает массив, внутрь функции передаётся не весь массив, а адрес его первого элемента.
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)
Здесь:
a— адрес первого элемента массива;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, перед
разыменованием нужна проверка.
Практические рекомендации
- Помни: массив в функцию передаётся как адрес первого элемента.
- Для обычных массивов передавай размер отдельным параметром.
- Используй
const, если функция не должна изменять массив или строку. - Не используй
sizeofпараметра-массива для определения количества элементов. - Проверяй границы массива в циклах.
- Для строк проходи по символам до
'\0'. - Если функция записывает строку в буфер, передавай размер буфера.
- Не изменяй строковые литералы.
- Для изменяемой строки используй массив
char. - Для функций чтения строки используй
const char *. - Если функция может получить
NULL, проверяй указатель перед разыменованием. - Выбирай форму параметра по смыслу:
a[]для массива,*aдля явного указателя.
Мини-разбор программы
Программа вводит строку, считает её длину собственной функцией, считает количество заданного символа и разворачивает строку.
#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--;
}
}
Разберём программу:
text— изменяемый массив символов;fgetsчитает строку с ограничением размера буфера;stringLengthполучает строку какconst char *и только читает её;countCharтакже только читает строку;invertполучаетchar s[], потому что изменяет символы строки;- все строковые функции идут по строке до
'\0'; - проверка на
NULLзащищает функции от неверного указателя.
Что нужно запомнить
- Массив в функцию передаётся как адрес первого элемента.
- В параметрах функции записи
int a[]иint *aблизки по смыслу. - Функция не знает размер обычного массива автоматически.
- Размер массива обычно передают отдельным параметром.
- Функция может изменить элементы массива, потому что работает с исходной областью памяти.
- Для чтения массива без изменения полезно использовать
const. a[i]эквивалентно*(a + i).- Параметр-массив внутри функции можно изменять как указатель.
- Имя настоящего массива в вызывающей функции изменять нельзя.
- Строка передаётся в функцию как адрес первого символа.
- Параметр строки можно записать как
char s[]илиchar *s. - Строка заканчивается символом
'\0', поэтому её длину можно найти проходом до этого символа. - Если функция изменяет строку, ей нужно передавать изменяемый массив, а не строковый литерал.
- Если функция записывает данные в строковый буфер, ей нужно знать размер буфера.
- Для двумерных массивов в параметрах нужно знать размер строки, то есть количество столбцов.
Самопроверка перед переходом дальше
- Что на самом деле передаётся в функцию при передаче массива?
- Почему параметр
int a[]близок по смыслу кint *a? - Почему размер массива нужно передавать отдельным параметром?
- Может ли функция изменить элементы массива, переданного ей как параметр?
- Чему эквивалентна запись
a[i]? - Чем отличается имя массива в
mainот параметра-массива в функции? - Почему внутри функции можно написать
a++, еслиa— параметр? - Почему нельзя написать
z++, еслиz— настоящий массив? - Для чего используется
constв параметре-массиве? - Почему
sizeof(a)внутри функции не даёт размер исходного массива? - Как строка передаётся в функцию?
- Почему для строки часто не передают длину отдельно?
- Что произойдёт, если строка не содержит
'\0'? - Почему нельзя передавать строковый литерал в функцию, которая изменяет строку?
- Как функция может вернуть результат обработки массива через обычный
return? - Как функция может изменить строку, переданную ей как параметр?
- Почему для двумерного массива нужно знать количество столбцов?