那些遇到过的问题

C++ 98/03 std :: is_constructible实现

Bro*_*thy 8 c++ compile-time sfinae c++11 c++03

我的业余爱好库的基本组件必须与C++ 98和C++ 11编译器一起使用.要了解和欣赏自己,我创建了几个类型支持的功能(如C++ 98级的实现enable_if,conditional,is_same,is_integral为了使用它们的时候没有C++ 11的支持等...).

然而,当我实施时,is_constructible我陷入困境.有没有任何模板魔术(某种SFINAE),我可以用它来实现它而不需要C++ 11支持(declval)？

当然在C++ 03中没有可变参数模板支持,所以我将把实现专门化到一定深度.主要问题是,是否存在可以决定T是否可以从给定类型构造的技术.

Dan*_*anh 7

这是可能的:

#include <iostream>

template<typename T, T Val>
struct integral_constant {
    typedef integral_constant type;
    typedef T value_type;
    enum {
        value = Val
    };
};

typedef integral_constant<bool, true> true_type;
typedef integral_constant<bool, false> false_type;

template<typename T>
struct remove_ref {
    typedef T type;
};

template<typename T>
struct remove_ref<T&> {
    typedef T type;
};

// is_base_of from https://stackoverflow.com/questions/2910979/how-does-is-base-of-work
namespace aux {
    typedef char yes[1];
    typedef char no[2];

    template <typename B, typename D>
    struct Host
    {
        operator B*() const;
        operator D*();
    };
}
template <typename B, typename D>
struct is_base_of
{
  template <typename T> 
  static aux::yes& check(D*, T);
  static aux::no& check(B*, int);

  static const bool value = sizeof(check(aux::Host<B,D>(), int())) == sizeof(aux::yes);
};

template<typename T>
struct remove_cv {
    typedef T type;
};
template<typename T>
struct remove_cv<const T> {
    typedef T type;
};
template<typename T>
struct remove_cv<volatile T> {
    typedef T type;
};
template<typename T>
struct remove_cv<const volatile T> {
    typedef T type;
};

template<typename T>
struct is_void : integral_constant<bool, false> {};
template<>
struct is_void<void> : integral_constant<bool, true> {};

template<class T>
struct type_identity {
    // Used to work around Visual C++ 2008's spurious error: "a function-style conversion to a built-in type can only take one argument"
    typedef T type;
};

template <bool, typename T, typename>
struct conditional {
    typedef T type;
};
template <typename T, typename U>
struct conditional<false, T, U> {
    typedef U type;
};


namespace aux {

template<typename T, typename U>
struct is_more_const : integral_constant<bool, false> {};

template<typename T, typename U>
struct is_more_const<const T, U> : integral_constant<bool, true> {};

template<typename T, typename U>
struct is_more_const<const T, const U> : integral_constant<bool, false> {};

template<typename T, typename U>
struct is_more_volatile : integral_constant<bool, false> {};

template<typename T, typename U>
struct is_more_volatile<volatile T, U> : integral_constant<bool, true> {};

template<typename T, typename U>
struct is_more_volatile<volatile T, volatile U> : integral_constant<bool, false> {};

template<typename T, typename U>
struct is_more_cv : integral_constant<bool, is_more_const<T,U>::value && is_more_volatile<T,U>::value> {};


    template<typename T>
    struct is_default_constructible {
        template<typename U>
        static yes& test(int(*)[sizeof(new U)]);
        template<typename U>
        static no& test(...);
        enum {
            value = sizeof(test<T>(0)) == sizeof(yes)
        };
    };    

    template<typename T, typename Arg>
    struct is_constructible_1 {
        template<typename U, typename Arg_>
        static yes& test(int(*)[sizeof(typename type_identity<U>::type(static_cast<Arg_>(*((typename remove_ref<Arg_>::type*)0))))]);
        template<typename U, typename Arg_>
        static no& test(...);
        enum {
            value = sizeof(test<T, Arg>(0)) == sizeof(yes)
        };
    };   

    // Base pointer construct from Derived Pointer
    template<typename T, typename U>
    struct is_constructible_1<T*, U*>
        : conditional<
            is_void<typename remove_cv<T>::type>::value,
            integral_constant<bool, true>,
            typename conditional<
                is_void<typename remove_cv<U>::type>::value,
                integral_constant<bool, false>,
                typename conditional<
                    is_more_cv<T, U>::value,
                    integral_constant<bool, false>,
                    is_base_of<T,U>
                >::type
            >::type
        >::type
    {};

    // Base pointer construct from Derived Pointer
    template<typename T, typename U>
    struct is_constructible_1<T&, U&>
        : conditional<
            is_more_cv<T, U>::value,
            integral_constant<bool, false>,
            is_base_of<T,U>
        >::type
    {};


    template<typename T, typename Arg1, typename Arg2>
    struct is_constructible_2 {
        template<typename U, typename Arg1_, typename Arg2_>
        static yes& test(int(*)[
            sizeof(typename type_identity<U>::type(
                static_cast<Arg1_>(*((typename remove_ref<Arg1_>::type*)0)),
                static_cast<Arg2_>(*((typename remove_ref<Arg2_>::type*)0))
                ))
            ]);
        template<typename U, typename Arg1_, typename Arg2_>
        static no& test(...);
        enum {
            value = sizeof(test<T, Arg1, Arg2>(0)) == sizeof(yes)
        };
    };
}

template<typename T, typename Arg1 = void, typename Arg2 = void>
struct is_constructible : integral_constant<bool, aux::is_constructible_2<T, Arg1, Arg2>::value> {

};

template<typename T, typename Arg>
struct is_constructible<T, Arg> : integral_constant<bool, aux::is_constructible_1<T, Arg>::value> {

};
template<typename T>
struct is_constructible<T> : integral_constant<bool, aux::is_default_constructible<T>::value> {

};

struct Foo {};
struct fuzz_explicit {};
struct fuzz_implicit {};
struct Fuzz {
    explicit Fuzz(fuzz_explicit);
    Fuzz(fuzz_implicit);
};
struct buzz_explicit {};
struct buzz_implicit {};
struct Buzz {
    explicit Buzz(buzz_explicit);
    Buzz(buzz_implicit);
};
struct Bar {
    Bar(int);
    Bar(int, double&);
    Bar(Fuzz);
    explicit Bar(Buzz);
};

struct Base {};
struct Derived : Base {};

#define TEST(X) std::cout << #X << X << '\n'

int main() {
    TEST((is_constructible<Foo>::value));
    TEST((is_constructible<Bar>::value));
    TEST((is_constructible<Foo, int>::value));
    TEST((is_constructible<Bar, int>::value));
    TEST((is_constructible<Foo, const Foo&>::value));
    TEST((is_constructible<Bar, Bar>::value));
    TEST((is_constructible<Bar, int, double>::value));
    TEST((is_constructible<Bar, int, double&>::value));
    TEST((is_constructible<Bar, int, const double&>::value));
    TEST((is_constructible<int*, void*>::value));
    TEST((is_constructible<void*, int*>::value));
    TEST((is_constructible<Base&, Derived&>::value));
    TEST((is_constructible<Derived*, Base*>::value));
    // via Fuzz
    TEST((is_constructible<Bar, fuzz_explicit>::value));
    TEST((is_constructible<Bar, fuzz_implicit>::value));
    // via Buzz
    TEST((is_constructible<Bar, buzz_explicit>::value));
    TEST((is_constructible<Bar, buzz_implicit>::value));
    // integer promotion
    TEST((is_constructible<Bar, char>::value));
    // integer conversion
    TEST((is_constructible<Bar, unsigned long>::value));
}
Run Code Online (Sandbox Code Playgroud)

您可以进一步扩展3个,4个,5个......参数的2个参数版本.

现场演示

这适用于g ++ 4.4.7

它不适用于g ++ 4.3.6

  • 您的版本隐式使用表达式SFINAE.虽然C++ 03似乎(明确地)不允许它,但许多实现在当时并没有支持它.所以不是一个令人满意的解决方案. (2认同)
  • 对于`is_constructible <X,int>`给出`enum X {};`仍然失败.也适用于`is_constructible <const Bar&,Fuzz&>`,以及指向成员的指针.这就是为什么`is_constructible`是由内在实现的原因. (2认同)

Bro*_*thy 5

我认为Danh的想法很棒！只需稍作修改，我们就可以消除运算符 new。（我有一个 C++98 enable_if 和 remove_reference 实现）。提到的 int*, void* 案例也适用于此实现。不需要新的操作员。只有旧的 g++ 支持仍然存在......

/********** std::remove_cv replacement **********/
template< typename T >
struct remove_const
{
    typedef T type;
};

template< typename T >
struct remove_const< const T >
{
    typedef T type;
};


template< typename T >
struct remove_volatile
{
    typedef T type;
};

template< typename T >
struct remove_volatile< volatile T >
{
    typedef T type;
};


template< typename T >
struct remove_cv
{
    typedef typename remove_volatile< typename remove_const< T >::type >::type type;
};


/********** std::is_pointer replacement *********/
template< typename T >
struct is_pointer_helper
{
    static const bool value = false;
};

template< typename T >
struct is_pointer_helper< T* >
{
    static const bool value = true;
};

template< typename T >
struct is_pointer
{
    static const bool value = is_pointer_helper< typename remove_cv< T >::type >::value;
};


/********** std::enable_if replacement **********/
template< bool CONDITION, typename TYPE = void >
struct enable_if
{
};

template< typename TYPE >
struct enable_if< true, TYPE >
{
    typedef TYPE type;
};


/****** std::remove_reference replacement *******/
template< typename T >
struct remove_reference
{
    typedef T type;
};

template< typename T >
struct remove_reference< T& >
{
    typedef T type;
};


/******* std::is_constructible replacement ******/
template< typename T, typename AT_1 = void, typename AT_2 = void, typename AT_3 = void, typename AT_4 = void >
class is_constructible_impl
{
private:
    template< typename C_T, typename C_AT_1, typename C_AT_2, typename C_AT_3, typename C_AT_4 >
    static bool test(
        typename c_std::enable_if<
            sizeof( C_T ) ==
            sizeof( C_T(
                static_cast< C_AT_1 >( *static_cast< typename c_std::remove_reference< C_AT_1 >::type* >( NULL ) ),
                static_cast< C_AT_2 >( *static_cast< typename c_std::remove_reference< C_AT_2 >::type* >( NULL ) ),
                static_cast< C_AT_3 >( *static_cast< typename c_std::remove_reference< C_AT_3 >::type* >( NULL ) ),
                static_cast< C_AT_4 >( *static_cast< typename c_std::remove_reference< C_AT_4 >::type* >( NULL ) )
            ) )
        >::type*
    );

    template< typename, typename, typename, typename, typename >
    static int test( ... );

public:
    static const bool value = ( sizeof( test< T, AT_1, AT_2, AT_3, AT_4 >( NULL ) ) == sizeof( bool ) );
};

template< typename T, typename AT_1, typename AT_2, typename AT_3 >
class is_constructible_impl< T, AT_1, AT_2, AT_3, void >
{
private:
    template< typename C_T, typename C_AT_1, typename C_AT_2, typename C_AT_3 >
    static bool test(
        typename c_std::enable_if<
            sizeof( C_T ) ==
            sizeof( C_T(
                static_cast< C_AT_1 >( *static_cast< typename c_std::remove_reference< C_AT_1 >::type* >( NULL ) ),
                static_cast< C_AT_2 >( *static_cast< typename c_std::remove_reference< C_AT_2 >::type* >( NULL ) ),
                static_cast< C_AT_3 >( *static_cast< typename c_std::remove_reference< C_AT_3 >::type* >( NULL ) )
            ) )
        >::type*
    );

    template< typename, typename, typename, typename >
    static int test( ... );

public:
    static const bool value = ( sizeof( test< T, AT_1, AT_2, AT_3 >( NULL ) ) == sizeof( bool ) );
};

template< typename T, typename AT_1, typename AT_2 >
class is_constructible_impl< T, AT_1, AT_2, void, void >
{
private:

    template< typename C_T, typename C_AT_1, typename C_AT_2 >
    static bool test(
        typename c_std::enable_if<
            sizeof( C_T ) ==
            sizeof( C_T(
                static_cast< C_AT_1 >( *static_cast< typename c_std::remove_reference< C_AT_1 >::type* >( NULL ) ),
                static_cast< C_AT_2 >( *static_cast< typename c_std::remove_reference< C_AT_2 >::type* >( NULL ) )
            ) )
        >::type*
    );

    template< typename, typename, typename >
    static int test( ... );

public:
    static const bool value = ( sizeof( test< T, AT_1, AT_2 >( NULL ) ) == sizeof( bool ) );
};

template< typename T, typename AT_1 >
class is_constructible_impl< T, AT_1, void, void, void >
{
private:
    template< typename C_T, typename C_AT_1 >
    static bool test(
        typename c_std::enable_if<
            sizeof( C_T ) ==
            sizeof( C_T(
                static_cast< C_AT_1 >( *static_cast< typename c_std::remove_reference< C_AT_1 >::type* >( NULL ) )
            ) )
        >::type*
    );

    template< typename, typename >
    static int test( ... );

public:
    static const bool value = ( sizeof( test< T, AT_1 >( NULL ) ) == sizeof( bool ) );
};

template< typename T >
class is_constructible_impl< T, void, void, void, void >
{
private:
    template< typename C_T >
    static C_T testFun( C_T );

    template< typename C_T >
    static bool test( typename c_std::enable_if< sizeof( C_T ) == sizeof( testFun( C_T() ) ) >::type* );

    template< typename >
    static int test( ... );

public:
    static const bool value = ( sizeof( test< T >( NULL ) ) == sizeof( bool ) );
};

template< typename T, typename AT_1 = void, typename AT_2 = void, typename AT_3 = void, typename AT_4 = void >
class is_constructible_impl_ptr
{
public:
    static const bool value = false;
};

template< typename T, typename AT_1 >
class is_constructible_impl_ptr< T, AT_1, typename enable_if< is_pointer< typename remove_reference< T >::type >::value, void >::type, void, void >
{
private:
    template< typename C_T >
    static bool test( C_T );

    template< typename >
    static int test( ... );

public:
    static const bool value = ( sizeof( test< T >( static_cast< AT_1 >( NULL ) ) ) == sizeof( bool ) );
};

template< typename T >
class is_constructible_impl_ptr< T, void, void, void, void >
{
public:
    static const bool value = true;
};

template< typename T, typename AT_1 = void, typename AT_2 = void, typename AT_3 = void, typename AT_4 = void >
class is_constructible
{
public:
    static const bool value = (
        is_pointer< typename remove_reference< T >::type >::value ?
            is_constructible_impl_ptr< T, AT_1, AT_2, AT_3, AT_4 >::value :
            is_constructible_impl< T, AT_1, AT_2, AT_3, AT_4 >::value
    );
};
Run Code Online (Sandbox Code Playgroud)

Yum*_*Yao 5

为了实现完全一致的 is_constructible，编译器支持是必要的。问题不在于可变参数模板模拟或select idiom(sizeof over decltype)。

实际上，即使在 gcc 8.x（4.x 到 7.x）之前，也存在一个 bug is_constructible<To, From>，因为它纯粹是由库代码实现的。To当是引用类型（即T&或）时，会发生该错误T&&。这同样适用于 clang libc++ 的库版本__libcpp_is_constructible<To, From>，但__is_constructible()自 c++11 支持以来，clang 就具有编译器支持，因此这从来都不是真正的问题。

不符合要求的情况是，在构造引用时，clang(libc++) 和 gcc(libstdc++) 使用的纯库实现使用 SFINAE 来检查格式是否static_cast<To>(declval<From>())良好。但有两种情况你必须显式使用cast而不是初始化语法（即T t(args...)）：

  1. 当从基类的引用强制转换为派生类的引用时：
    static_cast<Derived&>(declval<Base&>())有效，但必须始终显式使用强制转换，即Base& bref; Derived& dref = bref;不起作用，必须使用Derived& dref = static_cast<Derived&>(bref).
  2. 当从左值引用强制转换为右值引用时：
    static_cast<A&&>(declval<A&>())是有效的（您熟悉的 std::move()），但您必须始终显式使用强制转换，即A& lref; A&& ref = lref;不起作用，您必须使用A&& ref = static_cast<A&&>(lref);(ie A&& ref = std::move(lref);)

为了解决此类误报，除了 SFINAE 转换检查之外，libc++ 和 libstdc++ 中还存在额外的检查，以确保强制转换不是上述任何一种情况。

但这引入了一个新问题：如果存在用户定义的（显式的）转换，__is_constructible()则有效。但当转化也是上述场景之一时，就会出现漏报。

例如，下面的代码演示了基类到派生引用的转换场景。转换Base&为D1&或D2&需要显式转换，但是，还有一个用户定义的显式转换可以转换Base(&)为D1&. 因此is_constructible<D1&, Base&>::value评估结果为 true，而is_constructible<D2&, Base&>::value评估结果为 false。

struct D1;
struct D2;
struct Base {
    explicit operator D1&();
};

struct D1 : Base {
    D1(const D1&) = delete;
};
struct D2 : Base {};

int BtoD1() { // should be true
    return std::is_constructible<D1&, Base&>::value;
}
int BtoD2() { // should be false
    return std::is_constructible<D2&, Base&>::value;
}
Run Code Online (Sandbox Code Playgroud)

但库实现报告两者都是错误的。godbolt 链接自己尝试一下。您可以在 clang / gcc(<7) / gcc(>=8) 之间切换以查看结果如何变化。

归档时间：

查看次数：

1464 次

最近记录：

7 年 前
`is_base_of`是如何工作的？ 116
如何实现std :: is_constructible <T,Args>？ 6
更多相关链接
相关归档
如何让CMake基于GCC版本传递std = c ++ 14/c ++ 1y或c ++ 17/c ++ 1z？ 41
std :: set vs vector或maps的优点 39
为什么不是std :: algorithms constexpr,哪个可能？ 30
C++:嵌套模板类错误"非命名空间范围中的显式特化" 25
专门针对最小参数数量的可变参数模板模板参数:合法与否？ 16
文件范围的原子是否受初始化顺序惨败的影响？ 10
当在嵌套Lambda中使用`decltype`时,GCC Segfaults 9
如何延长局部变量的生命周期或使用引用的正确方法 8
我如何有条件地定义默认构造函数？ 7
如何检测通用lambda在C++ 14中是否不可编译？ 4
难疑归档
如何解决Git中的合并冲突 4600
如何在Python中安全地创建嵌套目录？ 3909
如何将某些内容附加到数组中？ 2895
.NET中的decimal,float和double之间的区别？ 2015
使用jQuery将表单数据转换为JavaScript对象 1580
为什么将0.1f改为0会使性能降低10倍？ 1491
如何使用jQuery获取元素的ID？ 1320
为什么我们需要C++中的虚函数？ 1223
sh和bash之间的区别 1194
致命错误:Python.h:没有这样的文件或目录 1042