Question

所以我有一个小型任务，其中一个问题是这样的：在一个100层的建筑物中，一个电梯从一楼开始，一路上，它停在不同的楼层接人。这是电梯停在的楼层：1（开始），5,14,29,80,99。找到电梯停在的每个楼层之间的差异。

我必须在这个迷你作业中尽可能多地使用课堂上学到的概念。所以我打算使用一个矢量（作为容器来容纳不同数量的楼层），一个函数（计算每个楼层之间的差异）并返回一个数组来打印差异。

如何编写一个带向量的函数，执行一些计算（在我的情况下为adjacent_difference）然后返回一个数组。

如果我要返回另一个向量，我就会这样做，但我不知道如何调整它以使其返回数组：

#include <iostream>
#include <vector>
#include <numeric>
#include <algorithm>

std::vector<int> calculateDiff (std::vector<int> v);

int main() 
{
  std::vector<int> vec {1, 5, 14, 29, 80, 99};

  for(auto iterator = vec.begin(); iterator != vec.end(); ++iterator)
  {
    std::cout << "Floors the lift stop at: ";
    std::cout << *iterator << std::endl;
  }

  std::vector<int> diff = calculateDiff(vec);

  for(auto iterator = diff.begin(); iterator != diff.end(); ++iterator)
  {
    std::cout << "Floor Difference: ";
    std::cout << *iterator << std::endl;
  }
}

std::vector<int> calculateDiff (std::vector<int> v)
{
  std::vector <int> floorDiff;

  floorDiff.resize(v.size());
  std::adjacent_difference(v.begin(), v.end(), floorDiff.begin());
  floorDiff.erase(floorDiff.begin()); //First element does not give the difference

  return floorDiff;
}

Answer 1

使用std::vector作为返回类型是最佳策略，IMO。但是，您必须稍微调整一下您的功能。您必须确保floorDiff与v一样大。

std::vector <int> floorDiff(v.size());

这是必要的，因为std::adjacent_difference不分配内存。

如果由于某种原因必须返回一个数组，你可以简单地扩展你的功能。

// Pass the input by const& to avoid the cost of a copy
// and to indicate that it won't be modified in the function.
int* calculateDiff (std::vector<int> const& v)
{
    std::vector <int> floorDiff(v.size());

    floorDiff.resize(v.size());
    std::adjacent_difference(v.begin(), v.end(), floorDiff.begin());

    int* arr = new int[floorDiff.size()-1];
    std::copy(floorDiff.begin()+1, floorDiff.end(), arr);
    return arr;
}

确保在调用函数中释放内存。

Answer 2

如果你觉得需要同时使用数组和向量，那就更多的是C ++＆＃34;反过来做 - 通过＆＃34;数组＆＃34; （即指针和大小）并返回一个向量你还可以做一些指针算术，并在<algorithm>中说明calculateDiff的一般性。

std::vector<int> calculateDiff (const int* v, size_t size)
{
  std::vector<int> floorDiff{size};
  std::adjacent_difference(v, v + size, floorDiff.begin());
  floorDiff.erase(floorDiff.begin())
  return floorDiff;
}

Answer 3

始终使用std::vector是正确的选择，但有一些风格问题可以改进

int main() 
{
  // vec is undescriptive of what it represents
  std::vector<int> floors {1, 5, 14, 29, 80, 99};

  for(auto iterator = floors.begin(); iterator != floors.end(); ++iterator)
  {
    // << can be chained
    std::cout << "Floors the lift stop at: " << *iterator << std::endl;
  }

  // Note that you repeat the "Floors the lift stop at: " 
  // If you only want one line, you can instead:      
  /* 
  std::cout << std::cout << "Floors the lift stop at: ";
  std::copy(floors.begin(), floors.end(), std::ostream_iterator<int>(std::cout, " "));
  std::cout << std::endl;
  */

  std::vector<int> diffs = calculateDiffs(vec);

  for(auto iterator = diffs.begin(); iterator != diffs.end(); ++iterator)
  {
    std::cout << "Floor Difference: " << *iterator << std::endl;
  }
  // and again, can std::copy into a std::ostream_iterator
}

std::vector<int> calculateDiffs (std::vector<int> values)
{
  // values is already a copy, as you passed by value
  std::adjacent_difference(values.begin(), values.end(), values.begin());
  values.erase(values.begin()); //First element does not give the difference

  return values;
}

采用向量并返回数组的函数

3 个答案: