C++将一个新数组传递给函数中的指针

C++ Passing an new array to a pointer from a function

本文关键字：函数 指针 一个 C++ 新数组 数组      更新时间：2023-10-16

EDIT：如果我试图在没有全局或静态以及没有向量o动态向量的情况下进行编辑，该怎么办？

我试图创建两个向量，并用一个函数传递一个新的向量，这个向量是两个数组中每个元素的商。即V1为1 1 2 2 3 4 V2为2 2 1 1 2预期的结果是2 2 2 6 8

我的问题是，当我从"quoziente"函数发送"r"结果时，因为我收到了随机数。我认为问题在于，函数只在执行过程中存在，但当它停止运行时，它也会随着变量而消亡。我该怎么办？我确信我把正确的地址传给了"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; i++) { 
  8         cin >> v[i];
  9     } 
 10 }
 11 
 12 void printarray(int* v, int dim) { 
 13     for(int i=0; i<dim; i++) { 
 14         cout << v[i] << " ";
 15     } 
 16     cout << endl;
 17 }
 18 
 19 int main() { 
 20     int v1[7];
 21     int v2[7];
 22     int *ris;
 23       
 24     cout << "V1";
 25     readarray(v1,7);
 26     cout << "V2";
 27     readarray(v2,7);
 28     ris = quoziente(v1,v2,7);
 29     cout << "V1";
 30     printarray(v1,7);
 31     cout << "V2";
 32     printarray(v2,7);
 33     cout << "ris ";
 34     printarray(ris,7);
 35     
 36     return 0;
 37 } 
 38 
 39 int* quoziente (int* v1, int* v2, int dim) { 
 40     int r[7]; 
 41 
 42     for(int i=0; i<dim; i++) { 
 43        r[i] = v1[i] * v2[i];
 44        cout << r[i] << " ";
 45     }
 46     cout << endl;
 47     return r;
 48 }

如果使用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;
}

当然，如前所述，还有std：：算法实用程序也更适合于此，例如std::transform——请参阅P0W的答案。然而，我猜这是为了你自己学习，所以研究std库容器在一般情况下是如何工作的也很重要。

你是对的，因为r是在堆栈上声明的，当它超出范围时，它将被删除。您需要在堆上分配内存，例如

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

确保在使用完delete [] ris;后调用它，以释放分配给的内存

在函数quoziente（）内部，

int r[7]<--这是在堆栈上分配的，所以当函数返回时它就死了。

解决问题的替代方法：-

1） 在quozinete（）中动态分配r。

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)

即将结果数组的指针作为另一个参数传递给函数。

例如，使r看起来像这样：

int *r = new int[7];

但您必须稍后将其删除。

或者使其成为静态

static int r[7];

并且您不必删除。但它与所有函数调用共享，因此您可能不会调用它两次，保留指针并期望结果保持不变。

您可能已经通过其他人回答解决了问题

我将向您展示另一种使用STL算法实现相同功能的方法

std:：transform和lambda函数

  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;}
                      );

查看演示

正如您在函数中定义的其他答案数组中解释的原因是tempary。它一直存在到功能存在。解决这个问题的不同方法是定义一个名为ris的数组，而不是指针，其大小与其他两个数组v1和v2相同。将其作为参数传递给函数，并将函数更改为

void quoziente (int* r, int* v1, int* v2, int dim) {  
  for(int i=0; i<dim; i++) { 
    r[i] = v1[i] * v2[i];
   cout << r[i] << " ";
 }
}

调用函数quoziente 时将res作为参数传递

quoziente(ris,v1,v2,7)

第二个解决方案是使用新操作符动态分配数组，正如其他答案中已经解释的那样。但请记住，当数组在主函数中不使用时，请将其删除。这不是推荐的做法，因为如果您不能访问函数代码，就无法知道我们必须删除main（）函数中的数组。即使你可以访问该功能，你通常也会忘记删除它。

也不建议使用声明变量/数组为静态的第三种解决方案，因为如果您为不同的数组分配重用该函数，则先前分配的数组也会更改。

相关文章：