Question

我有一个模板'Foo'，它拥有一个T，我希望它有一个可变参数构造函数，将其参数转发给T的构造函数：

template<typename T>
struct Foo {

    Foo()
        : t() {}

    Foo(const Foo& other)
        : t(other.t) {}

    template<typename ...Args>
    Foo(Args&&... args)
        : t(std::forward<Args>(args)...) {}

    T t;
};

但是，这会导致Foo无法复制：

int main(int argc, char* argv[]) {
    Foo<std::shared_ptr<int>> x(new int(42));
    decltype(x) copy_of_x(x);  // FAILS TO COMPILE
    return EXIT_SUCCESS;
}

因为，根据this answer，参数的非常量导致可变参数构造函数更好地匹配。我出于显而易见的原因，我不想强迫我的调用者使用const_cast。

我找到的一个可能的解决方案是为Foo编写一个“复制构造函数”，它采用非const Foo并使用构造函数转发：

Foo(Foo& other)
    : Foo(const_cast<const Foo&>(other)) {}

当定义了这个构造函数时，事情再次起作用：现在首选非const Foo参数copy ctor。然而，这对我来说似乎非常粗略，因为这种“治愈”似乎比疾病更糟糕。

是否有其他方法可以实现此效果，以指示自然复制构造函数应该优先于可变参数构造函数？如果没有，是否有定义这个非const参数复制构造函数的不良后果？

Answer 1

你可以使用一些丑陋的SFINAE和std::enable_if，但我不确定它比你的初始解决方案更好（事实上，我很确定它更糟糕！）：

#include <memory>
#include <type_traits>

// helper that was not included in C++11
template<bool B, typename T = void> using disable_if = std::enable_if<!B, T>;

template<typename T>
struct Foo {

    Foo() = default;
    Foo(const Foo &) = default;

    template<typename Arg, typename ...Args, typename = typename
        disable_if<
            sizeof...(Args) == 0 &&
            std::is_same<typename
                std::remove_reference<Arg>::type,
                Foo
            >::value
        >::type
    >
    Foo(Arg&& arg, Args&&... args)
        : t(std::forward<Arg>(arg), std::forward<Args>(args)...) {}

    T t;
};

int main(int argc, char* argv[]) {
    Foo<std::shared_ptr<int>> x(new int(42));
    decltype(x) copy_of_x(x);
    decltype(x) copy_of_temp(Foo<std::shared_ptr<int>>(new int));
    return 0;
}

Answer 2

最好的方法是不要做你正在做的事情。

也就是说，一个简单的解决方法是让variadic构造函数转发到基类构造函数，并带有一些特殊的第一个参数。

E.g。以下编译与MinGW g ++ 4.7.1：

#include <iostream>         // std::wcout, std::endl
#include <memory>           // std::shared_ptr
#include <stdlib.h>         // EXIT_SUCCESS
#include <tuple>
#include <utility>          // std::forward

void say( char const* const s ) { std::wcout << s << std::endl; }

template<typename T>
struct Foo;

namespace detail {
    template<typename T>
    struct Foo_Base
    {
        enum Variadic { variadic };

        Foo_Base()
            : t()
        { say( "default-init" ); }

        Foo_Base( Foo_Base const& other )
            : t( other.t )
        { say( "copy-init" ); }

        template<typename ...Args>
        Foo_Base( Variadic, Args&&... args )
            : t( std::forward<Args>(args)... )
        { say( "variadic-init" ); }

        T t;
    };

    template<typename T>
    struct Foo_ConstructorDispatch
        : public Foo_Base<T>
    {
        Foo_ConstructorDispatch()
            : Foo_Base<T>()
        {}

        template<typename ...Args>
        Foo_ConstructorDispatch( std::tuple<Foo<T>&>*, Args&&... args )
            : Foo_Base<T>( args... )
        {}

        template<typename ...Args>
        Foo_ConstructorDispatch( std::tuple<Foo<T> const&>*, Args&&... args )
            : Foo_Base<T>( args... )
        {}

        template<typename ...Args>
        Foo_ConstructorDispatch( void*, Args&&... args)
            : Foo_Base<T>( Foo_Base<T>::variadic, std::forward<Args>(args)... )
        {}
    };
}  // namespace detail

template<typename T>
struct Foo
    : public detail::Foo_ConstructorDispatch<T>
{
    template<typename ...Args>
    Foo( Args&&... args)
        : detail::Foo_ConstructorDispatch<T>(
            (std::tuple<Args...>*)0,
            std::forward<Args>(args)...
            )
    {}
};

int main()
{
    Foo<std::shared_ptr<int>>   x( new int( 42 ) );
    decltype(x)                 copy_of_x( x );
}

Answer 3

如果没有，定义这个非const参数复制构造函数会有什么不良后果吗？

我将忽略“If not”，因为是其他方法。但是您的方法的不利后果。以下仍使用模板构造函数

Foo<X> g();
Foo<X> f(g());

因为g()是一个右值，所以模板是一个更好的匹配，因为它将参数推导为右值引用。

Answer 4

当参数类型与此类型相同或派生时禁用构造函数：

template<typename ThisType, typename ... Args>
struct is_this_or_derived : public std::false_type {};

template<typename ThisType, typename T>
struct is_this_or_derived<ThisType, T>
    : public std::is_base_of<std::decay_t<ThisType>, std::decay_t<T> >::type {};

template<typename ThisType, typename ... Args>
using disable_for_this_and_derived 
      = std::enable_if_t<!is_this_or_derived<ThisType, Args ...>::value>;

将其用作

template<typename ...Args
        , typename = disable_for_this_and_derived<Foo, Args ...> >
                                                //^^^^
                                                //this needs to be adjusted for each class
Foo(Args&&... args) : t(std::forward<Args>(args)...) {}

如何防止可变参数构造函数优先于复制构造函数？

4 个答案: