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

EDIT: Что делать, если я пытаюсь сделать это без глобальных или статических и без векторных динамических векторов?

Я пытаюсь создать два вектора и иметь функцию, которая передает по адресу новый вектор, являющийся фактором каждого элемента из двух массивов. т.е. V1 равно 1 1 2 2 3 4 V 2 2 2 1 1 2 2 ожидаемый результат 2 2 2 2 6 8

Моя проблема в том, что я отправляю результат "r" из функции "quoziente", потому что получаю случайные числа. Я думаю, что проблема в том, что функция существует только во время ее выполнения, но когда она перестает работать, она тоже умирает со своими переменными. Как мне это сделать? Я уверен, что передаю правильный адрес "ris". Я попытался даже распечатать элементы операции, и я уверен, что я делаю правильную операцию. Любая помощь действительно ценится! благодаря

Здесь код:

1 #include <iostream>
 2 using namespace std;
 3
 4
 5
 6 void readarray (int* v, int dim) { 
 7 for(int i=0; i<dim; 8="" i++)="" {="" cin="">> v[i];
 9 } 
 10 }
 11 
 12 void printarray(int* v, int dim) { 
 13 for(int i=0; i</dim;></iostream>
6 ответов

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

int *r = new int[7]; // * was missing

убедитесь, что вы вызываете delete [] ris; когда вы закончите использовать его, чтобы освободить выделенную память


Это было бы намного проще, если бы вы использовали std :: vector или другие аналогичные контейнеры.

std::vector<int> quotient (std::vector<int> left, std::vector<int> right)
{ 
 std::vector<int> result;

 auto left_iterator = left.begin();
 auto left_end = left.end();
 auto right_iterator = right.begin();
 auto right_end = right.end();

 for(; left_iterator != left_end && right_iterator != right_end; 
 left_iterator++, right_iterator++) 
 { 
 int quotient = (*left_iterator) * (*right_iterator);
 result.push_back(quotient);
 std::cout << quotient << " ";
 }
 std::cout << std::endl;

 return result;
}
</int></int></int></int>

И, конечно, как уже упоминалось, есть также утилиты std :: algorithm, которые также подходят для этого, например std::transform - см. Ответ P0W. Тем не менее, я предполагаю, что это для вашего собственного обучения, поэтому изучение того, как контейнеры библиотеки std в общей работе также важны.


Внутри вашей функции quoziente(),

int r [7]; <- Это выделяется в стеке, поэтому он умирает, когда функция возвращается.

Альтернативные способы решения проблемы: -

1) Выделяйте r динамически внутри quozinete().

int *r = new int [7];

2) Объявите r как статический.

static int r[7];

3) Положите r в глобальном масштабе.

4) Объявите r в основном вместе с v1 и v2 как: -

int v1[7];
int v2[7];
int r[7];

И измените прототип quozinete как: -

void quoziente (int* v1, int* v2, int dim, int *r)

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


Поскольку причина объясняется в других массивах ответов, которые вы определяете в функции, она является температурой. Оно существует до тех пор, пока функция не существует. Другим способом решения этой проблемы является определение массива с именем ris а не указателя, такого же размера, как и для других двух массивов v1 и v2. Передайте его как аргумент функции и измените функцию на

void quoziente (int* r, int* v1, int* v2, int dim) { 
 for(int i=0; i
<p> Pass res как аргумент при вызове функции <code>quoziente

quoziente(ris,v1,v2,7)

Второе решение заключается в динамическом распределении массива с использованием нового оператора, как уже объяснялось в других ответах. Но не забудьте удалить массив, если он не будет использоваться в основной функции. И это не рекомендуется, потому что нет способа узнать, что мы должны удалить массив в функции main(), если у вас нет доступа к функциональному коду. И даже если у вас есть доступ к функции, вы, как правило, забываете ее удалить.

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


Возможно, вы уже выяснили проблему другими ответами

Я просто покажу вам другой способ добиться того же, используя алгоритм STL

std :: transform и лямбда-функция

int v1[7];
 int v2[7];
 int ris[7];

 std::transform(std::begin(v1), std::end(v1), 
 std::begin(v2), 
 std::begin(ris),
 [](const int &x, const int &y){ return x*y;}
 );

СМОТРЕТЬ ДЕМО


например make r выглядят следующим образом:

int *r = new int[7];

Но вы должны удалить его позже.

Или сделайте его статическим

static int r[7];

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

licensed under cc by-sa 3.0 with attribution.