验证变量参数是否为预期类型

Question

我目前正在编写一个函数，该函数将采用可变数量的参数。我将参数数量传递给函数，然后迭代参数列表。

每个传递的参数都应该是一个整数。我将把这个整数添加到稍后将使用的整数向量中。

我想确保某些小丑将来不会尝试将此函数传递给除整数之外的其他内容。我认识到我可以检查 va_arg 中的当前参数以确保它不为 NULL，并且我可以使用 isanum(va_arg()) 之类的东西来确定它是否是有效的整数。我想我什至可以检查 sizeof(va_arg) 并将其与 sizeof(int) 进行比较并确保它们相等。

我可以运行任何其他检查来验证我是否已传递了有效的整数？

预先感谢您的帮助

Answer 1

没有明智的方法可以做到这一点。可变参数函数的工作原理是将参数的所有原始二进制表示形式连接到堆栈上的一大块数据中。因此，它依赖于调用者和被调用者就参数的数量和类型达成一致（否则您最终将读取 int ，就好像它是 float）。

至于您的具体想法：

• va_arg() 是一个宏，它简单地将原始堆栈数据的一些字节解释为您指定的任何类型。因此，对其调用 sizeof() 只会告诉您所需的数据类型的大小。

• 一般来说，原始二进制数据不存在形成无效整数的模式。因此，假设的 isanum() 无法工作。

Answer 2

每个传递的参数都应该是一个整数。

如果您有 C++0x 编译器，我建议使用 initializer_list 而不是 varargs：

#include <initializer_list>

void foo(std::initializer_list<int> numbers)
{
    my_vector.insert(my_vector.end(), numbers.begin(), numbers.end());
}

int main()
{
    foo( {2, 3, 5, 7} );
}

这是直接且完全类型安全的。

Answer 3

每个传递的参数应该是
一个整数。我将添加这个
整数到整数向量，其中
稍后会用到。

那么为什么不只接受整数向量呢？

void AddIntegers(const std::vector<int>& vec);

然后，您始终可以使用迭代器将向量连接在一起。

或者创建一个像这样的接口：

void AddInteger(int newInt);

甚至这样：

void AddIntegers(const int* integers, unsigned int numIntegers);

template <unsigned int Size>
void AddIntegers(int (&integers)[Size])
{
    AddIntegers(integers, Size);
}

int main()
{
    int i[] = {1, 2, 3, 4};
    AddIntegers(i);
}

如果您需要使用 C++03 编译器，这些将起作用。如果您有 C++0x 编译器，则可以使用更高级的解决方案。

Answer 4

可变参数在设计上是不安全的。您无法以任何方式检查用户是否传递了正确的类型。 C++0x 通过可变参数模板来救援，但现在没有多少编译器支持它（据我所知，只有 GCC）。

Answer 5

不幸的是，确实没有办法做到这一点。像 printf() 这样的函数很容易通过传递无效或错误数量的参数而被搞乱。

在 C++ 中，这是一项高级功能，需要使用此类代码进行编程以确保传递正确的参数。

Answer 6

您无法使用可变参数进行任何类型的检查。我建议改用迭代器范围（如标准库函数）或可能使用 std::vector。这样类型就无法被破坏。

Answer 7

既然您使用的是 C++，那么重载一些运算符并一一传递参数怎么样？例如

class MyFunction {
  std::vector<int> param;
  public:
  MyFunction() { /* some initialisation? */ }
  MyFunction &operator,(int eatMe) {
    param.push_back(eatMe);
    return *this;
  }
  ~MyFunction() {
     //the implementation of your function goes here
  }
}

然后你可以这样调用它：

MyFunction(),2,3,5,7;

注意，使用逗号运算符可能看起来很可怕，但在这种情况下它实际上非常有帮助。它是最低可能的左结合运算符。

如果您的函数需要一些额外的参数，而不仅仅是未知长度的 int-s，您可以在构造函数中传递它们。

如果有人使用 int 以外的其他内容，则将使用默认的逗号运算符（评估左侧、丢弃、评估右侧）。如果您不喜欢这样 - 选择不同的运算符，例如类似流的 << 或类似 boost 的 %。

Answer 8

如果您仅限于 C++03 并且所有参数都应该是整数，则一种解决方案是简单地隐藏可变参数函数（例如在“详细”命名空间中）并创建一系列 1 到 N 数量的重载函数的论点。这些函数将是简单的内联函数，它将调用转发到实际函数的 vararg 版本。这样，您就有了一个真正的实现，没有运行时开销，并且向调用者公开了一个类型安全的接口（如果调用者需要超过 N 个参数，则始终可以使用 vararg 版本）。

Boost.PP 还可以帮助生成这些类型的重复模式。

当然，如果您有一定程度的 C++0x 支持，那么问题可以通过多种方式解决，包括初始化列表或可变参数模板。

Answer 9

只是为了说明我对 CygnusX1 答案的评论，您可以这样做：

class MyFunction {
  std::vector<int> params;
  public:
  MyFunction() { (*this)(); }
  MyFunction(int eatMe) { (*this)(eatMe); }
  MyFunction& operator()(int eatMe) {
    params.push_back(eatMe);
    return *this;
  }
  void operator()() { 
    // use params to do something interesting
  }
}

MyFunction(2)(3)(5)(7)();