Question

编辑：如果我尝试在没有全局或静态且没有矢量o动态向量的情况下怎么办？

我正在尝试创建两个向量，并且有一个函数可以通过地址传递一个新向量，该向量是两个数组中每个元素的商。即，V1是1 1 2 2 3 4 V2是2 2 1 1 2 2 预期的结果是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 }

Answer 1

如果您使用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 :: algorithm实用程序也更适合这一点，例如std::transform - 请参阅P0W的答案。但是，我猜这是为了你自己的学习，所以研究一般工作中的std库容器也很重要。

Answer 2

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

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

确保在使用完毕后拨打delete [] ris;，以释放您分配的内存

Answer 3

在你的函数quoziente（）中，

int r [7]; ＆lt; - 这是在堆栈上分配的，因此当函数返回时它会死掉。

解决问题的替代方法： -

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

int *r = new int [7];

2）将r声明为静态。

static int r[7];

3）将r置于全局范围内。

4）将v1和v2中的r声明为： -

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

将quozinete的原型更改为： -

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

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

Answer 4

例如make r如下所示：

int *r = new int[7];

但你必须稍后删除它。

或者让它静止

static int r[7];

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

Answer 5

您可能已经通过其他人的答案找出了问题

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

std::transform和lambda function

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

查看DEMO

Answer 6

正如在其他答案数组中解释的那样，你在函数中定义的是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)

第二种解决方案是使用new运算符动态分配数组，如其他答案中所述。但是请记住在主函数中没有使用它时删除该数组。这是不推荐的做法，因为如果你无法访问功能代码，就无法知道我们必须在main（）函数中删除数组。即使您可以访问功能，通常也会忘记删除它。

也不推荐第三种声明变量/数组静态的解决方案，因为如果重用该函数进行不同的数组分配，以前分配的数组也会被更改。

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

6 个答案: