Question

我的问题与C ++函数中的参数有关。有时，你可能会期望一个函数可以接受不同类型的参数，并且据我所知，这可以通过两种方式实现。一种是使用C ++新功能：函数重载（Polymorphism），另一种是使用'C'函数方式，如以下示例所示：

struct type0
{
    int a;
};

struct type1
{
    int a;
    int b;
};

struct type2
{
    int a;
    int b;
    int c;
};

void fun(int type, void *arg_structure)
{
    switch (type)
    {
    case 0:
        {
            struct type0 *mytype = (struct type0 *)(arg_structure);
            cout<<"a = "<<mytype->a<<endl;
            break;
        }

    case 1:
        {
            struct type1 * mytype= (struct type1 *)(arg_structure);
            cout<<"b = "<<mytype->b<<endl;
            break;
        }
    case 2:
        {
            struct type2 *mytype = (struct type2 *)(arg_structure);
            cout<<"c = "<<mytype->c<<endl;
            break;
        }
    default:
        break;
    }
}

int main () 
{
    struct type2 temp;
    temp.a = 1;
    temp.b = 2;
    temp.c = 3;
    fun(2,(void*)(&temp));

    return 0;
}

我的问题是：有没有其他方法可以在C ++中获得可更改的函数参数结构？谢谢！

Answer 1

当你要求'可变参数结构'而不是'可变参数类型'时，我会假设你在类型和参数数量方面要求灵活性。

如果是，您可以使用variadic functions：

void fn ( int cnt_params, ... ) {...}

或者，如果你有一个支持C ++ 11的编译器，variadic templates：

template <typename T, typename ...P>
void fn (T t, P ...p) {....}

否则，您可以使用重载或模板，正如其他人已经建议的那样。

Answer 2

C ++中有几种方法可以将不同类型的参数传递给同一个函数。首先，您必须确定何时确定参数的实际类型 - 在编译时还是在运行时？根据此决定，您可以使用适当的方法传递它：

对于编译时（静态）参数类型：

这些方法是类型安全的，必须优先使用。

对于运行时（动态）参数类型：

boost::variant
boost::any
Unions
Variadic functions
dynamic_cast（关于多态基类型指针/或引用）
static_cast（指向void）

我建议使用boost::variant或boost::any来提供他们提供的类型安全性。其他方法不是类型安全的，通常被认为是糟糕的设计决策。除非你真的需要它们，否则不要使用它们 - 或者更好地改进你的设计以避免它。

Answer 3

你有些困惑。函数重载与多态完全不同。

还有另一种c方式是可变参数列表。例如here解释。我相信使用这种机制可以实现printf()兄弟会。

在c++中，您可以使用几乎所有容器，例如std::vector或设置代替数组，std::map<string,Type>也可能适用于命名参数。

如果您需要一组混合类型，可以使用boost tuples（如果需要，可以使用+重载）。

c++模板机制可能很有用。

我认为标准容器，元组，模板和重载及其组合覆盖了99％的用例来处理参数。

如何在C ++中获得可更改的函数参数结构？

3 个答案: