2

我有一个定义如下的结构：

struct A : public B, public C
{
    A(const B& b) : B(b), C()
    {}

    template<typename... Args>
    A(Args&&... args) : B(), C(std::forward<Args>(args)...)
    {}
};

int main()
{
   B b;

   A sample1(b);
   A sample2(3); // For example, B has a B(int) constructor.
}

这不能正常工作，因为A(b)尝试使用第二个构造函数（非常量引用是首选选项，第一个构造函数是常量引用），但B没有任何B(A&).

此外，我想move为 B 添加一个构造函数：

struct A : public B, public C
{
    A(const B& b) : B(b), C()
    {}

    A(B&& b) : B(std::move(b)), C()
    {}

    template<typename... Args>
    A(Args&&... args) : B(), C(std::forward<Args>(args)...)
    {}
};

现在，最后一步是融合前两个构造函数：

struct A : public B, public C
{
   template<typename fw_B>
   A(fw_B&& b) : B(std::forward<fw_B>(b)), C()
   {}

   template<typename... Args>
   A(Args&&... args) : B(), C(std::forward<Args>(args)...)
   {}
 };

问题：如果第一个版本导致冲突，那么最后一个版本（我的最终目的）很明显它也不起作用。我怎样才能实现这个目标？

4

1 回答 1

2

如果参数的类型可转换为，则可能的解决方案是仅std::enable_if包含std::is_convertible第一个构造函数：bB

template <
  class fw_B,
  class = typename std::enable_if<std::is_convertible<fw_B, B>::value, T>::type>
A(fw_B&& b)

例如：

#include <iostream>
#include <type_traits>

struct B
{
    B() {}
    B(int) {}
};

struct C {};

struct A : B, C
{
    template <
      class T,
      class = typename std::enable_if<std::is_convertible<T, B>::value, T>::type> 
    A(T&& t) { std::cout << "A(T&&)\n"; }

    template <class... TArgs>
    A(TArgs&&... targs) { std::cout << "A(TArgs&&)\n"; }
};

int main()
{
    B b;

    A a1(b);
    A a2(4);
    A a3("hello");

    return 0;
}

输出：

在＆＆）
在＆＆）
A(Targs&&)

请参阅http://ideone.com/xJEjic上的演示。

于 2013-02-04T11:16:15.243 回答