Если функция принимает в качестве параметра массив, то фактически в эту функцию передается указатель на первый элемент массива. То есть как и в случае с указателями нам доступен адрес, по которому мы можем менять значения. Поэтому следующие объявления функции будут по сути равноценны:
void print(int numbers[]); void print(int *numbers);
Передадим в функцию массив:
#include <iostream>
void print(int[]);
int main()
{
int nums[] {1, 2, 3, 4, 5};
print(nums);
}
void print(int numbers[])
{
std::cout << "First number: " << numbers[0] << std::endl; // First number: 1
}
В данном случае функция print выводит на консоль первый элемент массива.
Теперь определим параметр как указатель:
#include <iostream>
void print(int*);
int main()
{
int nums[] {1, 2, 3, 4, 5};
print(nums);
}
void print(int *numbers)
{
std::cout << "First number: " << *numbers << std::endl;
}
Здесь также в функцию передается массив, однако параметр представляет указатель на первый элемент массива.
Поскольку параметр, определенный как массив, рассматривается именно как указатель на первый элемент, то мы не сможем корректно получить длину массива, например, следующим образом:
void print(int numbers[])
{
int size = sizeof(numbers) / sizeof(numbers[0]);
// или так
// size_t size = std::size(nums);
std::cout << size << std::endl;
}
И также мы не сможем использовать цикл for для перебора этого массива:
void print(int numbers[])
{
for (int n : numbers)
std::cout << n << std::endl;
}
Чтобы должным образом определять конец массив, перебирать элементы массива, обращаться к этим элементам, необходимо использовать специальный маркер, который бы сигнализировал об окончании массива. Для этого могут использоваться разные подходы.
Первый подход заключается в том, чтобы один из элементов массива сам сигнализировал о его окончании. В частности, массив символов может представлять строку - набор символов, который завершается нулевым символом '\0'. Фактически нулевой символ служит признком окончания символьного массива:
#include <iostream>
void print(char[]);
int main()
{
char chars[] {"Hello"};
print(chars);
}
void print(char chars[])
{
for (unsigned i{}; chars[i] != '\0'; i++)
{
std::cout << chars[i];
}
}
Однако при таком подходе мы должны быть уверены, что массив содержит такой подобный признак завершения. И если бы в данном случае нулевого байта не оказалось бы в строке, то это привело бы к неприятным последствиям. Поэтому обычно применяется другой подход, который заключается в передаче в функцию размера массива:
#include <iostream>
void print(int[], size_t);
int main()
{
int nums[]{1, 2, 3, 4, 5};
size_t n {std::size(nums)};
print(nums, n);
}
void print(int numbers[], size_t n)
{
for(size_t i {}; i < n; i++)
{
std::cout << numbers[i] << "\t";
}
}
Третий подход заключается в передаче указателя на конец массива. Можно вручную вычислять указатель на конец массива. А можно использовать встроенные библиотечные функции std::begin() и std::end():
int nums[] { 1, 2, 3, 4, 5 };
int *begin {std::begin(nums)}; // указатель на начало массива
int *end {std::end(nums)}; // указатель на конец массива
Причем end возвращает указатель не на последний элемент, а адрес за последним элементом в массиве.
Применим данные функции:
#include <iostream>
void print(int*, int*);
int main()
{
int nums[] { 1, 2, 3, 4, 5 };
int *begin {std::begin(nums)};
int *end {std::end(nums)};
print(begin, end);
}
void print(int *begin, int *end)
{
for (int *ptr {begin}; ptr != end; ptr++)
{
std::cout << *ptr << "\t";
}
}
Поскольку при передаче массива передается фактически указатель на первый элемент, то используя этот указатель, мы можем изменить элемены массива. Если нет необходимости в изменении массива, то лучше параметр-массив определять как константный:
#include <iostream>
void print(const int*, const size_t);
void twice(int*, const size_t);
int main()
{
int numbers[]{1, 2, 3, 4, 5};
size_t n = std::size(numbers);
print(numbers, n);
twice(numbers, n); // увеличиваем элементы массива в два раза
print(numbers, n);
}
void print(const int numbers[], const size_t n)
{
for(size_t i {}; i < n; i++)
{
std::cout << numbers[i] << "\t";
}
std::cout << std::endl;
}
void twice(int *numbers, const size_t n)
{
for(size_t i {}; i < n; i++)
{
numbers[i] = numbers[i] * 2;
}
}
В данном случае функция print просто выводит значения из массива, поэтому параметры этой функции помечаются как константные.
Функция twice изменяет элементы массива - увеличивает их в два раза, поэтому в этой функции параметр-массив является неконстантным. Причем поле выполнения функции twice массив numbers будет изменен.
Консольный вывод программы:
1 2 3 4 5 2 4 6 8 10
Еще один сценарий передачи массива в функцию представляет передача массива по ссылке. Прототип функции, которая принимает массив по ссылке, выглядит следующим образом:
void print(int (&)[]);
Обратите внимание на скобки в записи (&). Они указывают именно на то, что массив передается по ссылке. Пример использования:
#include <iostream>
void print(int (&)[], size_t);
int main()
{
int nums[] {1, 2, 3, 4, 5};
size_t count = std::size(nums);
print(nums, count);
}
void print(int (&numbers)[], size_t count)
{
for(size_t i{}; i < count; i++)
{
std::cout << numbers[i] << "\t";
}
}
Подобным образом можпо передавать константные ссылки на массивы.
void print(const int (&)[]);
С одной стороны, может показаться, что в передаче массива по ссылке нет большого смысла, поскольку при передачи массива по значению итак просто передается адрес этого массива. Но с другой стороны, передача массива по ссылке имеет некоторые преимущества. Во-первых, не копируется значение - адрес массива, мы напрямую работаем с оригинальным массивом. Во-вторых, передача массива по ссылке позволяет ограничить размер такого массива, соотвественно при компиляции компилятор уже будет знать, сколько элементов будет иметь массив.
#include <iostream>
void print(const int (&)[5]); // массив строго с 5 элементами
int main()
{
int nums1[] {1, 2, 3, 4, 5};
print(nums1);
}
void print(const int (&numbers)[5])
{
for(unsigned i{}; i < 5; i++)
{
std::cout << numbers[i] << "\t";
}
}
Здесь функция print принимает ссылку строго на массив с 5 элементами. И поскольку мы знаем точный размер массива, то нам нет необходимости передавать в функцию дополнительно размер массива.
Если же мы попробуем передать в функцию массив с другим количеством элементов, то на этапе компиляции мы столкнемся с ошибкой, как, например, в следующем случае:
int nums2[] {1, 2, 3, 4, 5, 6};
print(nums2); // ! Ошибка - в массиве nums2 6 элементов
Многомерный массив также передается как указатель на его первый элемент. В то же время поскольку элементами многомерного массива являются другие массивы, то указатель на первый элемент многомерного массива фактически будет представлять указатель на массив.
Когда определяется параметр как указатель на массив, размер второй размерности (а также всех последующих размерностей) должен быть определен, так как данный размер является частью типа элемента. Пример объявления:
void print(int (*numbers)[3]);
Здесь предполагается, что передаваемый массив будет двухмерным, и все его подмассивы будут иметь по 3 элемента. Стоит обратить внимание на скобки вокруг имени параметра, которые и позволяют определить параметр как указатель на массив. И от этой ситуации стоит отличать следующую:
void print(int *numbers[3])
В данном случае параметр определен как массив указателей, а не как указатель на массив.
Рассмотрим применение указателя на массив в качестве параметра:
#include <iostream>
void print(const int(*)[3], const size_t);
int main()
{
int table[][3] { {1, 2, 3}, {4, 5, 6}, {7, 8, 9} };
// количество строк или подмассивов
size_t rowsCount {std::size(table)};
print(table, rowsCount);
}
void print(const int (*rows)[3], const size_t rowsCount)
{
// количество столбцов или элементов в каждом подмассиве
size_t columnsCount {std::size(*rows)};
for(size_t i{}; i < rowsCount; i++)
{
for (size_t j{}; j < columnsCount; j++)
{
std::cout << rows[i][j] << "\t";
}
std::cout << std::endl;
}
}
В функции main определяется двухмерный массив - он состоит из трех подмассивов. Каждый подмассив имеет по три элемента.
В функцию print вместе с массивом передается и число строк - по сути число подмассивов. В самой функции print получаем количество элементов в
каждом подмассиве и с помощью двух циклов перебираем все элементы. С помощью выражения rows[0] можно обратиться к первому подмассиву
в двухмерном массиве, а с помощью выражения rows[0][0] - к первому элементу первого подмассива. И таким образом, манипулируя индексами
можно перебрать весь двухмерный массив.
В итоге мы получим следующий консольный вывод:
1 2 3 4 5 6 7 8 9
Также мы могли бы использовать нотацию массивов при объявлении и определении функции print, которая может показаться проще, нежели нотация указателей. Но в этом случае опять же надо было бы указать явным образом вторую размерность:
#include <iostream>
void print(const int[][3], const size_t);
int main()
{
int table[][3] { {1, 2, 3}, {4, 5, 6}, {7, 8, 9} };
// количество строк или подмассивов
size_t rowsCount {std::size(table)};
print(table, rowsCount);
}
void print(const int rows[][3], const size_t rowsCount)
{
// количество столбцов или элементов в каждом подмассиве
size_t columnsCount {std::size(rows[0])};
for( size_t i{}; i < rowsCount; i++)
{
for (size_t j{}; j < columnsCount; j++)
{
std::cout << rows[i][j] << "\t";
}
std::cout << std::endl;
}
}