is_assignable的可能实现

Possible Implementation of is_assignable

本文关键字：实现 assignable is      更新时间：2023-10-16

我正在努力适应一些tmp概念。

这里有一个解决方案来检查是否有两种类型可分配：这是最重要的部分：

template<typename _Tp, typename _Up>
class __is_assignable_helper: public __sfinae_types {
template<typename _Tp1, typename _Up1>
static decltype(std::declval<_Tp1>() = std::declval<_Up1>(), __one())
__test(int) {}
template<typename, typename>
static __two __test(...) {}
public:
static constexpr bool value = sizeof(__test<_Tp, _Up>(0)) == 1;
};

现在我试着用一些其他的sfinae技巧，但不起作用。。

template<typename _Tp, typename _Up, typename = void>
class __is_assignable_helper2
{
public:
static constexpr bool value = false;
};

template<typename _Tp, typename _Up>
class __is_assignable_helper2<_Tp, _Up, 
                                typename std::enable_if<
                                std::is_same<typename
                                decltype(std::declval<_Tp>()=    std::declval<_Up>(), char)
,char >::value
                                                                     , void
                                                        >::type>
{
public:
 static constexpr bool value = true;
};

GCC说：错误：模板参数的数量错误(1，应该是2(>：：值

他不接受decltype作为is_same中的模板参数。

有人能解释一下这个错误信息吗？并提出解决方案？

更新：

好的！它有效！我写的是char，而不是char｛｝。。。。

下一个问题：

是否有更优雅的实现？

这里有一个可能的实现：

#include<type_traits>
#include<string>
template<typename T, typename U, typename = void>
struct is_assignable: std::false_type {};
template<typename T, typename U>
struct is_assignable<T, U, decltype(std::declval<T>() = std::declval<U>(), void())>: std::true_type {};
int main() {
    static_assert(is_assignable<std::string, const char*>::value, "!");
    static_assert(not is_assignable<const char*, std::string>::value, "!");
    static_assert(is_assignable<int &, int &>::value, "!");
}

这适用于非基本类型。我应该想象一下，只要稍微调整一下，它就可以用于int = long转换等

#include <iostream>
#include <utility>
#include <string>
// fallback helper for when the true case won't compile - returns false_type
template<class T, class From>
std::false_type is_assignable_impl(...) { return {}; }
// this overload preferred if decltype(T = From) yields a type   
// returns a true_type
template<class T, class From>
auto
is_assignable_impl(int)
-> decltype(std::declval<T>() = std::declval<From>(), void(), std::true_type())
{ return {}; }
// derived from either false_type or true_type    
template<class T, class From>
struct my_assignable : decltype(is_assignable_impl<T, From>(0)) {};
// a test...
using namespace std;
auto main() -> int
{
    cout << my_assignable<std::string, const char*>::value << endl;
    cout << my_assignable<const char*, std::string>::value << endl;
    return 0;
}

预期输出：

1
0
相关文章：