В этой статье мы обсудим, как можно использовать массивы с функциями в C++. Как правило, массивы можно передавать функциям в качестве аргументов точно так же, как мы передаем функции переменным.
Но оценка формальных параметров немного отличается, когда речь идет о массивах. Прежде чем приступить к изучению передачи массивов функциям, нам нужно кратко обсудить концепцию указателя на массив.
Указатель на массив
Рассмотрим следующий массив, содержащий первые пять чисел последовательности Фибоначчи:
|
1 |
int fibSeq[5] = {1,1,2,3,5}; |
Давайте объявим указатель fibPtr на этот массив:
|
1 2 |
int* fibPtr; fibPtr = fibSeq; |
Когда мы печатаем содержимое fibPtr, вывод будет первым элементом массива fibSeq. Это связано с тем, что имя массива без квадратных скобок оценивается как указатель на первый элемент массива. Таким образом, в приведенном выше примере имя «fibSeq» указывает на первый элемент массива «fibSeq».
Ниже представлено то же самое, только графически:
Как показано на изображении выше, fibPtr указывает на первый элемент массива. Таким образом, используя арифметику указателей, мы можем напечатать все элементы массива, просто используя fibPtr.
Например, выражение *(fibPtr + 1) будет указывать на второй элемент массива и так далее.
Давайте поместим это в программу и проверим вывод «fibSeq» и «fibPtr»:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
#include <iostream> #include <string> using namespace std; int main() { int fibSeq[5] = {1,1,2,3,5}; int* fibPtr; fibPtr = fibSeq; cout<<"\nfibSeq points to :"<<*fibSeq; cout<<"\nfibSeq[0]: "<<*fibPtr; cout<<"\nfibSeq[1]: "<<*(fibPtr + 1); cout<<"\nfibSeq[2]: "<<*(fibPtr + 2); cout<<"\nfibSeq[3]: "<<*(fibPtr + 3); cout<<"\nfibSeq[4]: "<<*(fibPtr + 4); } } |
Вывод данных:
fibSeq указывает на: 1
|
1 2 3 4 5 |
fibSeq[0]: 1 fibSeq[1]: 1 fibSeq[2]: 2 fibSeq[3]: 3 fibSeq[4]: 5 |
В приведенном выше примере мы объявляем переменную-указатель fibPtr, а затем делаем так, чтобы она указывала на массив, присваивая имя массива fibPtr. Тем самым, мы заставляем fibPtr указывать на первый элемент массива. Затем мы печатаем все значения массива, используя fibPtr.
Передача массивов в функцию
Когда дело доходит до функций, то мы передаем массивы в функцию так же, как мы передаем в функцию переменные. Но мы не передаем переменную массива типа [].
Вместо этого мы передаем указатель на массив, т.е. имя массива, которое указывает на первый элемент массива. Тогда формальный параметр, который принимает этот указатель, на самом деле будет являться переменной массива. Когда мы передаем указатель, мы можем напрямую изменять массив внутри функции.
Рассмотрим следующую программу, которая вычисляет квадрат каждого элемента первых пяти элементов в последовательности Фибоначчи, чтобы продемонстрировать передачу массива в функцию:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
#include <iostream> #include <string> using namespace std; void fibSeqSquare(int fibSeq[]) { for(int i=0;i<5;i++) { fibSeq[i] *= fibSeq[i]; } } int main() { int fibSeq[5] = {1,1,2,3,5}; fibSeqSquare(fibSeq); for(int i=0;i<5;i++) { cout<<fibSeq[i]<<" "; } } |
В приведенном выше примере мы вычисляем квадрат каждого элемента в последовательности Фибоначчи. Этот квадрат вычисляется внутри функции. Следовательно, мы передаем имя массива функции «fibSeqSquare» при вызове функции из main. Внутри функции мы вычисляем квадраты каждого элемента.
Поскольку мы передали ссылку на массив с помощью указателя, любые изменения, которые мы делаем с массивом внутри функции, будут отражать массив. Следовательно, когда мы печатаем массив в основной функции, мы получаем квадраты каждого элемента в качестве вывода.
В приведенном выше примере вы видели, что не аргумент массива (формальный параметр) функции fibSeqSquare указывает не размер массива, а только квадратные скобки ([]), чтобы указать, что это массив. Это один из способов указания аргументов массива.
Другой способ указать аргумент массива в списке формальных параметров — указать размер массива в квадратных скобках. Оба аргумента работают одинаково. Это просто два способа указания аргументов массива.
В следующем примере показан аргумент Array, указанный с размером:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
#include <iostream> #include <string> using namespace std; void displayFibSeq(int fibSeq[5]) { for(int i=0;i<5;i++) { cout<<fibSeq[i]<<" "; } } int main() { int fibSeq[5] = {1,1,2,3,5}; displayFibSeq(fibSeq); return 0; } |
В приведенном выше примере есть функция для отображения последовательности Фибоначчи. Функция имеет параметр в виде массива, в котором мы также указали размер массива.
Еще, мы можем передавать многомерные массивы функциям так же, как показано выше.
Возврат массивов из функций
Когда дело доходит до возврата массива из функции, то C++ не позволит нам возвращать из функции весь массив. Однако мы можем создать функцию для возврата указателя на массив. Но в этом есть загвоздка.
Рассмотрим следующий фрагмент кода:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
int* funcArray() { int arr[3] = {1,2,3}; return arr; } int main() { int* aryPtr = funcArray(); cout<<aryPtr[0]; cout<<aryPtr[1]; cout<<aryPtr[2]; return 0; } |
Хотя вышеприведенная программа просто возвращает указатель на первый элемент массива из функции, она работает не так, как ожидалось. Мы не можем гарантировать, что программа выдаст правильный результат.
Это связано с тем, что мы возвращаем локальную переменную из функции, и не можем быть уверены, будет ли она в области видимости к моменту ее возврата или нет.
Таким образом, C++ не поддерживает возврат массивов из функций.
Если нам вообще нужно вернуть массивы из функции, нам нужно использовать любой из следующих методов:
1) Возврат динамически выделенных массивов
Мы можем вернуть указатель массива из динамически выделенного массива. Для этого используем оператор new для динамического выделения массива. Поскольку это динамический массив, он будет находиться в области видимости, если мы не «удалим» массив. Следовательно, программа будет работать нормально, когда мы вернем массив.
Это показано в следующем примере:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
#include <iostream> #include <string> using namespace std; int* funcArray() { int* arr = new int[3]; arr[0]=1; arr[1]=2; arr[2]=3; return arr; } int main() { int* aryPtr = funcArray(); cout<<aryPtr[0]<<" "<<aryPtr[1]<<" "<<aryPtr[2]; return 0; } |
Вывод данных:
1 2 3
2) Возврат статических массивов
Поскольку статические переменные/массивы имеют область действия по всей программе, мы также можем возвращать статические массивы из функций. Мы можем взять пример, чтобы продемонстрировать это. Все тоже самое, что и в предыдущем примере, с той лишь разницей, что в этом примере мы использовали статический массив вместо динамически выделяемого массива.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
#include <iostream> #include <string> using namespace std; int* funcArray() { static int arr[3]; arr[0]=1; arr[1]=2; arr[2]=3; return arr; } int main() { int* aryPtr = funcArray(); cout<<aryPtr[0]<<" "<<aryPtr[1]<<" "<<aryPtr[2]; return 0; } |
Вывод данных:
1 2 3
Мы также можем использовать структуру, чтобы обернуть в нее массив, а затем вернуть эту структуру. Таким образом, мы естественным образом вернем массив из функции. Но это не очень удобный метод возврата массивов.
Вывод
Таким образом, в этой статье мы подробно обсудили массивы с точки зрения функций. Мы надеемся, что данная статья помогла вам развеять все сомнения и неправильные представления о массивах и функциях C++. В следующей статье мы разберем работу со строками в C++ и приведем несколько примеров для понимания.
С Уважением, МониторБанк