33

我有一个模板'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;
}

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

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

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

定义此构造函数后，事情又开始了：现在首选非 const Foo 参数复制 ctor。然而，这对我来说似乎很粗略，因为这种“治疗”似乎比疾病更糟糕。

是否有另一种方法可以实现这种效果，表明自然复制构造函数应该优先于可变参数构造函数？如果没有，定义这个非常量参数复制构造函数是否有任何不利后果？

4

4 回答 4

15

您可以使用一些丑陋的 SFINAE with 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;
}
于 2012-12-18T17:25:16.933 回答
2

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

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

例如，以下使用 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 );
}
于 2012-12-18T18:22:20.767 回答
2

如果没有，定义这个非常量参数复制构造函数是否有任何不利后果？

我将忽略“如果不是”，因为还有其他方法。但是你的方法有一个不利的后果。下面仍然使用模板构造函数

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

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

于 2012-12-18T22:36:21.187 回答
1

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

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)...) {}
于 2016-02-11T22:15:11.707 回答