0

编辑：如果我试图在没有全局或静态且没有矢量或动态矢量的情况下进行操作怎么办？

我正在尝试创建两个向量并有一个函数通过地址传递一个新向量，该向量是两个数组的每个元素的商。即 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 }
4

6 回答 6

5

如果您使用 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 的答案。但是，我猜这是为了您自己的学习，因此了解标准库容器在一般工作中的工作方式也很重要。

于 2013-09-02T10:51:13.417 回答
3

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

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

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

于 2013-09-02T10:33:44.260 回答
2

在你的函数 quoziente() 中，

诠释r[7]；<-- 这是在堆栈上分配的，所以当函数返回时它会死掉。

解决问题的替代方法：-

1) 在 quozinete() 中动态分配 r。

int *r = new int [7];

2) 将 r 声明为静态的。

static int r[7];

3) 将 r 放在全局范围内。

4) 在 main 中声明 r 以及 v1 和 v2 为：-

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

并将quozinete的原型更改为：-

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

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

于 2013-09-02T10:47:40.853 回答
1

例如使r看起来像这样：

int *r = new int[7];

但是您必须稍后将其删除。

或者让它成为静态的

static int r[7];

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

于 2013-09-02T10:33:55.763 回答
1

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

我将向您展示另一种使用 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;}
                      );

看演示

于 2013-09-02T10:47:11.210 回答
1

正如您在函数中定义的其他答案数组中解释的原因是临时的。它存在直到功能存在。解决此问题的不同方法是定义一个名为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] << " ";
 }
}

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

quoziente(ris,v1,v2,7)

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

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

于 2013-09-02T11:05:14.550 回答