Question

如何实现X构造函数并使用可变参数列表初始化Base类？

#include<cstdarg>

class A
{
private:
    int m_a;
public:
    A(int a): m_a(a) {}
};

class B: public A
{
private:
    int m_b;
public:
    B(int a, int b):A(a), m_b(b){}
};

template <class Base>
class X: public Base
{
public:
    //X(...):Base(...)
};

int main()
{
    X<A> x(7)
    X<B> x(3,5);
    return 0;
}

我不能修改A，B类。不能使用c ++ 11或更高版本的标准

Answer 1

template <class Base>
class X: public Base
{
public:
    X(int a, int b) : Base(a, b) { }
    X(int a) : Base(a) { }
};

是的，这确实有效。 X的构造函数在您尝试使用它们之前不会被实例化，所以一切都很好。没有讨厌的varargs处理！

Answer 2

如果你可以使用C ++ 11，我宁愿做

class A
{
private:
    int m_a;
public:
    A(int a): m_a(a) {}
};

class B: public A
{
private:
    int m_b;
public:
    B(int a, int b):A(a), m_b(b){}
};

template <class Base>
class X: public Base
{
public:
    using Base::Base; //Magic trick
};

int main()
{
    X<A> x1(7);
    X<B> x2(3,5);
    return 0;
}

而不是使用可变参数模板的元技巧。

使用Base :: Base;从基类继承所有构造函数。

Answer 3

一种C ++ 11方式是使用可变参数模板

template <class Base>
class X: public Base
{
public:
    X(const X&) = default;
    X(X&&) = default;

    template <typename ...Ts>
    X(Ts&&...args) : Base(std::forward<Ts>(args)...) {}
};

在C ++ 03中移植它的一种方法：

template <class Base>
class X: public Base
{
public:
    X() : Base(t) {}
    X(const X& x) : Base(x) {}

    template <typename T> X(const T& t) : Base(t) {}
    template <typename T1, typename T2> X(const T1& t1, const T2& t2) : Base(t1, t2) {}
    template <typename T1, typename T2, typename T3>
    X(const T1& t1, const T2& t2, const T3& t3) : Base(t1, t2, t3) {}
    // ... Up to N args
};

模板继承和varargs

3 个答案: