如何在C ++ 11中定义SFINAE和静态断言的约束

Question

我正在尝试使用模板进行序列化/反序列化，现在有了一些工作。显然，在实现它时，我遇到了许多带有数百个编译器错误日志的麻烦。在进一步扩展我的库之前，我想使用SFINAE（我目前几乎只使用它）和static_asserts来保证它。

不要乱用我的lib，我正在沙盒中训练：

http://coliru.stacked-crooked.com/a/9eb4eaefaac90fc0

我想定义一些谓词：

• is_a_base检查从Base派生的对象。
• is_insertable＆is_extractable检查是否已为此类型定义了operator >>和operator <<。

我希望能够将这些谓词用于SFINAE特化和static_assert。

#include <sstream>
#include <iostream>

//forward declaration
class Base;

//"Template typedef" to check predicates
template <typename T>
using is_a_Base = typename std::enable_if<std::is_base_of<Base, T>::value, void>::type;

template <typename T, typename is = std::istream>
using is_extractable = decltype (is{} >> T{});

template <typename T, typename os = std::ostream>
using is_insertable = decltype (os{} << T{});

//Test classes
class Base{
    public:
        std::string getStr(){ return "Base.getStr()";}
};
class Derived: public Base {};

class Other{};

//A template class with its specializations with SFINAE
template <typename T, typename Enable = void>
class C{
    public:
        static void f(T& o){
            std::cout << "f<T> default !" << std::endl;
    }
};

template<typename T>
class C<T, is_a_Base<T>>
{
    public:
        static void f (T& o)
        {
            std::cout << "f<is_a_A>() ! " << o.getStr() << std::endl;
        }
};

template<typename T>
class C<T, is_insertable<T> >
{
    public:
        static void f (T& o)
        {
            std::cout << "f<is_insertable() ! " << o << std::endl;
        }
};


template<typename T>
std::string g(T& ref)
{
    //static_assert(is_a_Base<T>, "T is not a Base"); //can't figure out the syntax here
    return ref.getStr();
}



int main(){
    Base a;
    Derived b;
    int myint = 1;
    std::string str="toto";

    Other oops;


    C<Base>::f(a);
    C<Derived>::f(b);
    C<int>::f(myint);      //Not calling is_insertable ??
    C<std::string>::f(str); //Not calling is_insertable ??
    C<Other>::f(oops);

    std::cout << "g:" << g(a) << std::endl;
    //std::cout << "g:" << g(oops) << std::endl; //should be blasted by the static assert
}

结果：

f<is_a_A>() ! Base.getStr()
f<is_a_A>() ! Base.getStr()
f<T> default !
f<T> default !
f<T> default !
g:Base.getStr()

到目前为止，is_a_base正在为SFINAE工作。但是，is_insertable对int和string变量不起作用？另外，我无法弄清楚如何正确地将is_a_base谓词重用到我的assert语句中。

（由于我受限于交叉编译器不支持超出C ++ 11，我无法使用C ++ 14及以后的优势。）

Answer 1

您正在使用SFINAE通过默认参数C选择void的特化。这意味着专业化的签名必须正确替换，但也会生成void以便选择专门化。就目前而言，您的流特征：

template <typename T, typename is = std::istream>
using is_extractable = decltype (is{} >> T{});

template <typename T, typename os = std::ostream>
using is_insertable = decltype (os{} << T{});

......实际上是从operator >>（resp.<<）产生返回类型，通常是is &（resp.os &）。你的命名也有点令人困惑，因为is_...暗示了一个布尔值，它们不是。因此我建议修复：

模板

using enable_if_base = typename std::enable_if<std::is_base_of<Base, T>::value>::type;
//                                              `void` is the default already ^

template <typename T, typename is = std::istream>
using enable_if_extractable = decltype (std::declval<is &>() >> std::declval<T &>(), void());
//                                                                                 ^^^^^^^^

template <typename T, typename os = std::ostream>
using enable_if_insertable = decltype (std::declval<os &>() << std::declval<T const &>(), void());
//                                                                                      ^^^^^^^^

请注意，我还用适当合格的T{}s替换了std::declval，因为你不能假设相关类型实际上是默认构造的 - 实际上，std::istream和std::ostream不是。

Answer 2

两个问题：

1. std::ostream和std::istream没有默认的构造函数，因此以您的方式创建它们会导致替换失败，因此主模板被用作后备。使用declval<T&>以避免使用默认构造函数创建临时值。
2. 主模板中的第二个模板参数必须是void才能被选中。正如你所知，它返回[i/o]s{} << T{}（原文如此）的结果类型，其中std::ostream&和std::istream&为另一个。您可以通过将第二个参数包装在std::void_t中来解决此问题。

#1

template <typename T, typename is = std::istream>
using is_extractable = decltype (std::declval<is&>() >> T{});

template <typename T, typename os = std::ostream>
using is_insertable = decltype (std::declval<os&>() << T{});

#2

template<typename T>
class C<T, std::void_t<is_a_Base<T>>>

template<typename T>
class C<T, std::void_t<is_insertable<T>>>