函数调用的参数太多，预期的单个参数"nums"，有 3 个参数

Question

我正在编写一个算法，以生成数组(或在所提供的代码上下文中的向量)的所有排列。

第二，这不是我的代码，我用它作为一个学习经验;然而，我知道这是一个涉及"permute"的类。成员，并且仍然需要一个main函数才能被调用。

我的问题:我不知道如何调用这个类的方式，将输入"(1,2,3)"然后生成排列。我已经尝试了下面的方法以及其他输入值的方法，如[1,2,3]或({1,2,3})，但到目前为止还没有工作。

我得到的错误是

函数调用参数太多，期望单个参数'nums'，有3个参数

代码如下:

#include <stdio.h>
#include <vector>
class Solution
{
public:
std::vector<std::vector<int> > permute(std::vector<int>& nums)
{
if (nums.size() <= 1)
return { nums };
std::vector<std::vector<int> > result;
for (int i = 0; i < nums.size(); ++i)
{
std::vector<int> v(nums.begin(), nums.end());
v.erase(v.begin() + i);
auto res = permute(v);
for (int j = 0; j < res.size(); ++j)
{
std::vector<int> _v = res[j];
_v.insert(_v.begin(), nums[j]);
result.push_back(_v);
}
}
return result;
}
};
int main()
{
Solution obj;
obj.permute(1, 2, 3);
return 0;
}

Answer 1

您的函数将参数作为引用，因此您不能将临时值作为参数。该参数未被修改，因此将其更改为constant:

std::vector<std::vector<int> > permute(const std::vector<int>& nums)

之后，你可以用一个临时值调用函数:

obj.permute({1, 2, 3});

Answer 2

• 您为permute提供了3个参数，但它只接受一个参数。或者像这样调用函数

  obj.permute({1, 2, 3});
  

  或者您可以添加一个permute过载，它接受一个参数包，并将其扩展到原始的permute函数。下面的代码可以用obj.permute(1, 2, 3);调用它

  template<class... Args>
  std::vector<std::vector<int>> permute(Args&&... args) {
  return permute({std::forward<Args>(args)...});
  }
  

你试图绑定一个非const引用到提供的临时参数，这是不允许的。要么按值取它，要么使它成为const&。const&可以绑定到一个暂时的。

例子:

#include <iostream>
#include <utility>   // std::forward
#include <vector>
class Solution {
public:
std::vector<std::vector<int>> permute(const std::vector<int>& nums) {
//                                        ^^^^^
if(nums.size() <= 1) return {nums};

std::vector<std::vector<int>> result;
for(int i = 0; i < nums.size(); ++i) {
std::vector<int> v(nums.begin(), nums.end());
v.erase(v.begin() + i);
auto res = permute(v);
for(int j = 0; j < res.size(); ++j) {
std::vector<int> _v = res[j];
_v.insert(_v.begin(), nums[j]);
result.push_back(_v);
}
}
return result;
}
// Added overload:
template<class... Args>
std::vector<std::vector<int>> permute(Args&&... args) {
return permute({std::forward<Args>(args)...});
}
};
int main() {
Solution obj;
auto res = obj.permute({1, 2, 3});    // note: {1,2,3}
// auto res = obj.permute(1, 2, 3);   // would use the added overload
for(auto& inner : res) {
for(auto v : inner) std::cout << ' ' << v;
std::cout << 'n';
}    
}