c++ - 继承具有可变参数的构造函数

Question

我有一个带有两个构造函数的简单类 A。其中之一具有 veradic 参数。 B 类只是派生类，我想使用 A 类的派生构造函数实例化 B 类。

一切正常，直到我想使用可变参数的特殊功能。最后一条语句引发编译器错误:

"sorry, unimplemented: passing arguments to ellipsis of inherited constructor B::B(int, ...) [inherited from A]".

我该如何解决这个问题。

class A {
    public:
        A(float f){
            std::cout << "Do something" << std::endl;
        }

        A(int a, ...){
            std::cout << "Do something else" << std::endl;
        }
};

class B : public A {
    using A::A;
};

int main(){

    A a(2.0f); // works
    B b(1.0f); // works

    A c(1, 2, 3); // works
    B d(1); // works
    B e(1, 2); // doesn't work

    return 0;
}

输出将是:

Do something
Do something
Do something else
Do something else
ERROR :(

Answer 1

首先，我想提一下 Variadic arguments是一个 C 语言特性，它只是在 C++ 中继承(并为了兼容性而保留)。

现代 C++ 提供类型保存替代方案，如 Parameter pack , Initializer Lists应该首选哪个恕我直言。

不过，话虽如此，现在是一个可能的解决方案。

我曾经在尝试模仿类似 printf() 的东西时发现它。那时，我注意到vprintf()的存在并了解为什么以及它有什么好处。

这是基本思路，我试图解决OP的困境:

#include <cstdarg>
#include <iostream>

class A {
  public:
    A(float f)
    {
      std::cout << "A::A(" << f << ")\n";
    }

    A(int n, ...)
    {
      std::cout << "A::A(";
      va_list args;
      va_start(args, n);
      getArgs(n, args);
      va_end(args);
      std::cout << ")\n";
    }
  protected:
    A()
    {
      std::cout << "A::A()\n";
    }

    void getArgs(int n, va_list args)
    {
      std::cout << n;
      for (int i = 0; i < n; ++i) {
        float arg = va_arg(args, double); // Please, note, float is not a standard argument type.
        std::cout << ", " << arg;
      }
    }
};

class B: public A {
  public:
    B(float f): A(f)
    {
      std::cout << "in B::B(float)\n";
    }

    B(int n, ...)
    {
      std::cout << "in B::B(";
      va_list args;
      va_start(args, n);
      getArgs(n, args);
      va_end(args);
      std::cout << ")\n";
    }
};

#define DEBUG(...) std::cout << #__VA_ARGS__ << ";\n"; __VA_ARGS__ 

int main()
{
  std::cout << "Test flavors of A::A():\n";
  DEBUG(A a1(1.23f));
  DEBUG(A a2(3, 1.2f, 2.3f, 3.4f));
  std::cout << "Test flavors of B::B():\n";
  DEBUG(B b1(1.23f));
  DEBUG(B b2(3, 1.2f, 2.3f, 3.4f));
}

输出:

Test flavors of A::A():
A a1(1.23f);
A::A(1.23)
A a2(3, 1.2f, 2.3f, 3.4f);
A::A(3, 1.2, 2.3, 3.4)
Test flavors of B::B():
B b1(1.23f);
A::A(1.23)
in B::B(float)
B b2(3, 1.2f, 2.3f, 3.4f);
A::A()
in B::B(3, 1.2, 2.3, 3.4)

Live Demo on coliru

提示:

恕我直言，可变参数的常见陷阱是默认参数提升，例如提到这里:Variadic arguments – Default conversions . (我在示例代码中相关的地方用 resp.comment 对此进行了评论。)