Как передать динамический массив в функцию c

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

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

При написании приведенной программы, ячейки для двумерного массива были динамически созданы внутри функции main () Сразу же был дописан код очистки памяти от создаваемого массива. Если написать не сразу, то потом легко запутаться или забыть. Очистка памяти нужна только и только тогда когда массив больше не нужен . Между кусками кода выделения памяти под двумерный массив и очистки от него памяти был написан вызов двух функций. Первая функция принимает двумерный массив в качестве аргумента. Благодаря тому, что принимаемый параметр является указателем, то любые изменения массива внутри функции, влияют на этот массив вне функции напрямую (Передали на обработку -> Получили обновленный) . Нужно заполнить массив значениями. Чтобы заполнить массив значениями, нужно знать его размерность. Чтобы функция занесения данных в двумерный динамический массив знала размерность, туда были переданы эти данные. Осталось только использовать ввод данных с помощью циклов. Не думаю, что по этим циклам должны возникнуть вопросы. Функция маленькая и удобочитаемая. Главное понимать, что

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

Следующая функция принимает динамический массив как обычный двумерный. Чтобы массив принялся в таком виде, в котором был только что создан, обязательно принимающую его функцию вызывать до очистки памяти от нужного массива. По принимаемым параметрам эта функция похожа на ту, которая создавала двумерный массив. Используется указатель на указатель, и указываются данные размерности. Чтобы массив был не в одну строчку, была произведена проверка деления числа нацело. Если кто-то использует другие способы приведения массива к хорошему виду, то легко можно использовать удобные ему. Чтобы элементы массива не слились воедино, был использован элемент табуляции.

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

Главное четко осознавать

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

Как передать динамический массив в функцию c

Как передать динамический массив в функцию?Найти скалярное произведение векторов С++

#include using namespace std; int amount(int k) < cout > k; return k; > int vector_1() < int k = amount(k); int* vect1 = new int[k]; cout > vect1[i]; > for (int i = 0; i < k; ++i) < cout return k; return vect1[k]; > int vector_2() < int k = amount(k); int* vect2 = new int[k]; cout > vect2[i]; > for (int i = 0; i < k; ++i) < cout return k; return vect2[k]; > int main(int k, int * vect1, int* vect2) < float res; res = 0.0; int Vect1 = *vect1; int Vect2 = *vect2; for (int i = 0; i cout

У меня 2 функции для каждого массива( массив - это координаты функции). Кроме них есть ещё первая функция amount, от которой я вызываю в функции vector_1 и vector_2 число k - количество координат. Последняя - это main, где происходит само умножение. Но проблема в том, что я не могу понять, как передать массив и члены массива(координаты)

______________________
Используйте тег [CODE] (кнопка [CODE] в форме сообщения) при вставке кода на форум. Подробнее в FAQ

Последний раз редактировалось Serge_Bliznykov; 14.10.2019 в 09:52 .

Функции и динамические двумерные массивы

Здравствуйте, любители C++, как я вам и обещал, сегодня мы с вами разберем динамические массивы и напишем свои собственные функции. За основу мы возьмем задание из статьи №3, где мы работали с двумерным массивом размерностью 8×8. Вспомним то задание(оригинал в статье №3) и запишем его немножко в другом виде:
Для заданной матрицы размером n на m найти такие k, что k-ая строка матрицы совпадает с k-ым столбцом.
Найти сумму элементов в тех строках, которые содержат хотя бы один отрицательный элемент. Начнем:
Ну во первых я должен вас поздравить: мы переходим к функциональному программированию, и это уже можно считать достижением.

#include conio.h> #include iostream> #include cstdlib> #include ctime> using namespace std; int** sozdanie(int n, int m); void initialize( int** A, int n, int m); // будем передавать динамический массив и размерность в качестве параметра void compare(int** A, int n, int m); void summa (int** A, int n, int m);

Для начала нам следует подключить стандартные библиотеки, пространство имен, и, самое главное, объявить наши функции.
Объявляют функцию в C++ следующим образом: 1) Тип возвращаемых данных
То есть если написать в самом начале int, то это значит что функция вернет какое то целочисленное значение, как видите, функция sozdanie возвращает динамический двумерный массив целых чисел(да именно так он обозначается int**), если же написать в начале объявления тип void(как во всех остальных функциях), то это означает, что функция ничего не возвращает(но не путайте, она все же что то делает с нашими данными). 2) Имя функции
Здесь все просто: мы просто придумываем имя нашим функциям(желательно, чтобы имя отражало суть функции). 3) Список параметров
Чтобы наши функции что то делали, им нужно передать какие то данные. Например функция sozdanie, она принимает 2 параметра: число строк n и число столбцов m, и на основе этих данных создает двумерный массив. Только не путайте: мы пока что только объявили эти функции, после этого нам следует описать их, то есть написать, что каждая из них делает.

int** sozdanie(int n, int m) < int **A;// Создаем матрицу введенной размерности A = new int *[n]; // через массив указателей for (int i = 0; i < n; i++) < A[i] = new int [m]; > return A; > void initialize(int** A, int n, int m)// Функция заполнения < srand(time(0)); for(int i = 0; i < n; i++ ) < for(int j = 0; j < m; j++ ) < A[i][j] = rand()%11 - 5 ; cout " "; > cout endl; > >

Таким образом описываются функции в C++, следует отметить, что описывать их можно как до main, так и после него.
Разберем функцию создания динамического массива: Для начала нам следует создать одномерный массив указателей, затем в цикле в каждый указатель мы записываем еще одномерный массив, таким образом у нас выходит массив массивов, или, двумерный массив в котором n строк и m столбцов. Так как мы работаем с динамическим массивом, то следует выделять память под него, это делается с помощью ключевого слова new. Вторая функция, как и в статье №3, заполняет массив рандомными числами и выводит на экран. Заметьте, что в качестве параметра этой функции передается и сам массив.

void compare(int** A, int n, int m) // Функция сравнения < int count(0), k(0); for(int i = 0; i < n; i++ ) < for(int j = 0; j < m; j++ ) < if(A[i][j] == A[j][i]) < count++; > if (count == n) < cout " \n " << i + 1 " строка совпадает с " << i + 1 " столбцом " endl; k ++; > > count = 0; > if(k == 0) cout "\n\n Нет совпадающих строк и столбцов" endl; > void summa (int** A, int n, int m) // Функция суммы < int result(0); for(int i = 0; i < n; i++ ) < for(int j = 0; j < m; j++ ) < if(A[i][j] < 0) < for(int count = 0; count < m; count ++) < result += A[i][count]; > cout "\n Сумма элементов на " << i + 1 " строке равна "<< result endl; j = m; result = 0; > > > >

Здесь подробно останавливаться не будем, так как рабочие моменты уже были пояснены в той самой насущной статье №3, поэтому сразу перейдем к main:

int main() < setlocale(LC_ALL, "Russian"); int n(0), m(0); cout " Введите кол-во строк в массиве" endl; cin >> n; cout " \nВведите кол-во столбцов в массиве" endl; cin >> m; cout endl; int **A; A = sozdanie(n,m); // Создаем через функцию initialize(A, n, m); // заполняем матрицу compare(A, n, m); // сравниваем столбцы и строки summa(A, n, m); // считаем сумму элементов на строке с отрицательным элементом for ( int i = 0; i < n; i++ ) < delete [] A[ i ]; > delete [] A; // Освобождение памяти _getch(); return 0; >

Создаем переменные строки и столбцы, далее просим пользователя ввести вручную значения для этих переменных(именно поэтому массив называется динамическим). После, вызываем наши функции: вызов осуществляется как имя функции + параметры в () И не лишним было бы освободить память по окончанию работы с динамическим массивом в C++ Скачать исходники На этом сегодня все. Пишите свои комментарии, ваше мнение очень важно для нас!

Поделиться ссылкой:

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

Слышала, что массив можно передавать в функцию в виде указателя. Откуда можно взять этот указатель? И как потом через него получать доступ к элементам исходного массива? Заранее спасибо.

Отслеживать
11.5k 8 8 золотых знаков 42 42 серебряных знака 69 69 бронзовых знаков
задан 4 ноя 2017 в 17:18
47 1 1 золотой знак 1 1 серебряный знак 3 3 бронзовых знака

2 ответа 2

Сортировка: Сброс на вариант по умолчанию

Вас интересует это?

int func(int * arr, int n) < . >. int * array = new int[20]; func(array,20); 

Если нет - сформулируйте свой вопрос поточнее.

Отслеживать
ответ дан 4 ноя 2017 в 17:21
219k 15 15 золотых знаков 119 119 серебряных знаков 230 230 бронзовых знаков

Когда говорят про передачу массива в виде указателя, на самом деле подразумевают передачу пары «указатель на первый элемент массива — количество элементов массива»:

int func(int* base, size_t count) < // . >

Доступ же к элементам производится, как и в случае обычных массивов, через индексацию (при этом мы притворяемся, что указатель base — это и есть сам массив):

int item = base[i]; 

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

Теперь о том, почему мы передаём количество элементов (параметр count ). Дело в том, что пока мы работаем с переменной-массивом, компилятор знает его размер и может в любой момент предоставить его нам (через sizeof(array) / sizeof(array[0]) ). Однако, как только мы начинаем работать с указателями, всякая информация о массиве теряется, а потому мы должны передавать её явно, вместе с указателем. При создании же динамического массива мы сразу же получаем указатель, а потому вынуждены хранить и передавать количество его элементов явно.

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