c++序列化-《C++那些事》之SFINAE

我们需要在“template std::string serialize(const T& obj)”签名上找到一个巧妙的SFINAE解决方案。我带给您难题的最后一部分，称为enable_if。

如您所见，我们可以使用enable if根据编译时表达式触发替换失败。现在我们可以在“template std::string serialize(const T& obj)”签名上使用这个错误来调度到正确的版本。最后，我们找到了问题的真正解决办法：

template <class T> typename enable_if<hasSerialize::value, std::string>::type serialize(const T& obj)
{
    return obj.serialize();
}

template <class T> typename enable_if<!hasSerialize::value, std::string>::type serialize(const T& obj)
{
    return to_string(obj);
}

A a;
B b;
C c;

// The following lines work like a charm!
std::cout << serialize(a) << std::endl;
std::cout << serialize(b) << std::endl;
std::cout << serialize(c) << std::endl;

值得注意两个细节！

首先，我们在返回类型上使用enable_if，以保持参数推导，否则我们将必须明确指定类型”serialize(a)”。

其次，即使使用to_string的版本也必须使用enable_if，否则serialize（b）将有两个潜在的可用重载并引起歧义。如果您想查看此C ++ 98版本的完整代码，这里是要点。在C ++ 11中，生活要容易得多，所以让我们看一下这个新标准的美妙之处！

注意:同样重要的是要知道这段代码在一个表达式上创建了一个SFINAE(“&C::serialize”)。虽然这个特性不是c++ 98标准所要求的，但是它已经在使用了，这取决于您的编译器。它确实成为c++ 11中一个安全的选择。

2.6 小结

以上C++98方式总结说出下面问题：

SFINAE-143.C++11方式

SFINAE-14

在2000年的大世纪闰年之后，人们对未来几年相当乐观。有些人甚至决定为像我这样的下一代c++程序员设计一个新的标准!这个标准不仅可以减轻TMP的麻烦(模板元编程的副作用)，而且在第一个十年就可以使用，因此它的代码名为c++ 0x。好吧，这个标准不幸地出现在下一个十年（2011 ==> C ++ 11），但是它带来了许多有趣的特性。让我们回顾一下他们。

3.1 decltype, declval, auto & co

decltype

还记得sizeof操作符对传递给它的表达式进行“伪计算”，然后返回表达式类型的大小吗?

c++ 11增加了一个新的运算符decltype。decltype给出了它要计算的表达式的类型。由于我的善良，我不会让你举一个例子，直接给你：

B b;
decltype(b.serialize()) test = "test"; // Evaluate b.serialize(), which is typed as std::string.
// Equivalent to std::string test = "test";

declval是一个实用程序，可为您提供对无法轻松构造的类型的对象的“伪引用”。declval对于我们的SFINAE结构确实非常方便。cppreference示例非常简单，因此这里是一个副本：

struct Default {
    int foo() const {return 1;}
};

struct NonDefault {
    NonDefault(const NonDefault&) {}
    int foo() const {return 1;}
};

int main()
{
    decltype(Default().foo()) n1 = 1; // int n1
//  decltype(NonDefault().foo()) n2 = n1; // error: no default constructor
    decltype(std::declval().foo()) n2 = n1; // int n2
    std::cout << "n2 = " << n2 << 'n';
}

auto

auto specifier 指定被声明的变量的类型将被自动推导。auto相当于c#中的var。auto在c++ 11中也有一个不太出名的函数声明用法。这里有一个很好的例子：

bool f();
auto test = f(); // Famous usage, auto deduced that test is a boolean, hurray!



//                             vvv t wasn't declare at that point, it will be after as a parameter!
template <typename T> decltype(t.serialize()) g(const T& t) {   } // Compilation error

// Less famous usage:
//                    vvv auto delayed the return type specification!
//                    vvv                vvv the return type is specified here and use t!
template <typename T> auto g(const T& t) -> decltype(t.serialize()) {   } // No compilation error.

如您所见，auto允许使用尾随返回类型语法，并使用decltype以及涉及函数参数之一的表达式。这是否意味着我们可以使用它来测试SFINAE序列化的存在？

是的，沃森博士！decltype很快就会亮起来，您必须等待C ++ 14才能完成这种棘手的自动用法（但是由于它是C ++ 11的功能，因此最终会在这里出现）。

constexpr

c++ 11还提供了一种执行编译时计算的新方法!

新的关键字constexpr是编译器的一个提示，这意味着这个表达式是常量，可以在编译时直接求值。在c++ 11中，constexpr有很多规则，只能使用一小部VIEs(非常重要的表达式)表达式(没有循环……)!我们仍然有足够的时间来创建编译时阶乘函数：

constexpr int factorial(int n)
{
    return n <= 1? 1 : (n * factorial(n - 1));
}

int i = factorial(5); // Call to a constexpr function.
// Will be replace by a good compiler by:
// int i = 120;

constexpr增加了STL中std :: true_type和std :: false_type的使用。顾名思义，这些类型封装了constexpr布尔值“ true”和constrexpr布尔值“ false”。它们最重要的属性是类或结构可以从它们继承。例如：

struct testStruct : std::true_type { }; // Inherit from the true type.

constexpr bool testVar = testStruct(); // Generate a compile-time testStruct.
bool test = testStruct::value; // Equivalent to: test = true;
test = testVar; // true_type has a constexpr converter operator, equivalent to: test = true;

4.融合时间

4.1 第一种解决方案

在烹饪中，一个好的食谱需要把所有最好的配料按正确的比例混合。如果您不想在晚餐时使用1998年的意大利面条代码，那么让我们重新访问2011年的c++ 98 hasSerialize和serialize函数，其中包含“新鲜”的成分。让我们从消除腐烂的方法开始，使用美味的decltype和bake 一点点的constexpr而不是sizeof。在烤箱中烘烤15分钟后（或出现新的头痛症状），您将获得：

template<class T>
struct hasSerialize {
    // We test if the type has serialize using decltype and declval.
    template<typename C>
    static constexpr decltype(std::declval().serialize(), bool()) test(int /* unused */) {
        // We can return values, thanks to constexpr instead of playing with sizeof.
        return true;
    }

    template<typename C>
    static constexpr bool test(...) {
        return false;
    }

    // int is used to give the precedence!
    static constexpr bool value = test(int());
};

您可能对我使用decltype感到有些困惑。C ++逗号运算符“，”可以创建多个表达式链。在decltype中，将评估所有表达式，但仅将最后一个表达式视为该类型。序列化不需要任何更改，减去了STL中现在提供了enable_if函数的事实。

测试如下：

template<class T>
std::string serialize(const T &obj) {
    // 不加constexpr 报错：error: no member named 'serialize' in 'A'.
    // C++17的constexpr
    if constexpr (hasSerialize::value)
        return obj.serialize();
    else
        return to_string(obj);
}

int main() {
    A a;
    B b;
    C c;

    // The following lines work like a charm!
    std::cout << serialize(a) << std::endl;
    std::cout << serialize(b) << std::endl;
    std::cout << serialize(c) << std::endl;
}

4.2 第二种解决方案

Boost.Hanna文档中介绍的另一个使用std :: true_type和std :: false_type的C ++ 11解决方案是这样的：

template<typename T, typename=std::string>
struct hasSerialize : std::false_type {

};
template<typename T>
struct hasSerialize<T, decltype(std::declval().serialize())> : std::true_type {

};
// 测试同上

我个人认为，这种解决方案更加狡猾！它依赖于不太知名的默认模板参数。但是，如果您的灵魂已经（堆栈）损坏，您可能会意识到默认参数会在专业领域传播。因此，当我们使用hasSerialize :: value时，默认参数会起作用，并且实际上我们在 primary template 和 specialisation方面都正在寻找hasSerialize :: value。同时，将处理decltype的替换和求值，并且如果OurType具有返回std :: string的序列化方法，则我们的specialisation会被替换为具有签名hasSerialize ，否则替换将失败。因此，在良好情况下，specialisation优先。在这种情况下，将可以使用std :: void_t C ++ 17帮助程序。无论如何，这是您可以使用的要点！

我告诉过你，第二种解决方案隐藏了很多复杂性，我们仍然有很多c++ 11特性没有被利用，比如nullptr、lambda、r-values。不用担心，我们将在c++ 14中使用其中的一些。

5.C++14的优势5.2 auto与lambda

根据我的XFCE环境右上角的公历，我们是2015年！我可以安全地在我最喜欢的编译器上打开C ++ 14编译标志，不是吗？好吧，我可以使用clang（MSVC是否使用maya日历？）。再一次，让我们探索新功能，并使用它们来构建精彩的东西！就像我在本文开头所承诺的那样，我们甚至将重新创建一个is_valid。

auto

（1）返回类型推断的结果

c++ 14中的一些很酷的特性来自于auto关键字的轻松使用(用于类型推断的关键字)。现在，auto可以用于函数或方法的返回类型。例如：

auto myFunction() // Automagically figures out that myFunction returns ints.
{
    return int();
}

只要类型很容易被编译器“猜测”，它就可以工作。毕竟我们是在用c++编程，而不是OCaml

lambda

（2）函数爱好者的功能

c++ 11介绍了lambda。lambda具有以下语法：

[capture-list](params) -> non-mandatory-return-type { ...body... }

在我们的例子中，一个有用的例子是：

int main() {
    B b;
    auto l1 = [](B &b) { return b.serialize(); }; // Return type figured-out by the return statement.
    auto l3 = [](B &b) -> std::string { return b.serialize(); }; // Fixed return type.
    auto l2 = [](B &b) -> decltype(b.serialize()) { return b.serialize(); }; // Return type dependant to the B type.

    std::cout << l1(b) << std::endl; // Output: I am a B!
    std::cout << l2(b) << std::endl; // Output: I am a B!
    std::cout << l3(b) << std::endl; // Output: I am a B!
}

c++ 14给lambdas带来了一个小的变化，但是带来了巨大的影响!

Lambdas接受自动参数:根据参数推导出参数类型。Lambdas被实现为一个具有新创建的未命名类型(也称为闭包类型)的对象。如果一个lambda有一些自动参数，它的“函子操作符”操作符()将被简单地模板化。让我们来看看：

void fun(A a,B b,C c) {
    // ***** Simple lambda unamed type *****
    auto l4 = [](int a, int b) { return a + b; };
    std::cout << l4(4, 5) << std::endl; // Output 9.

    // Equivalent to:
    struct l4UnamedType {
        int operator()(int a, int b) const {
            return a + b;
        }
    };
    l4UnamedType l4Equivalent = l4UnamedType();
    std::cout << l4Equivalent(4, 5) << std::endl; // Output 9 too.
    // ***** auto parameters lambda unnamed type *****
    // b's type is automagically deduced!
    auto l5 = [](auto &t) -> decltype(t.serialize()) { return t.serialize(); };

    std::cout << l5(b) << std::endl; // Output: I am a B!
//    std::cout << l5(a) << std::endl; // Error: no member named 'serialize' in 'A'.
    l5UnamedType l5Equivalent = l5UnamedType();
    std::cout << l5Equivalent(b) << std::endl; // Output: I am a B!
//    std::cout << l5Equivalent(a) << std::endl; // Error: no member named 'serialize' in 'A'.
}

除了lambda本身，我们对生成的未命名类型更感兴趣:它的lambda操作符()可以用作SFINAE!

正如您所看到的，编写lambda比编写等价类型要简单。这应该使你想起我最初的解决办法：

// Check if a type has a serialize method.
auto hasSerialize = hana::is_valid([](auto&& x) -> decltype(x.serialize()) { });

好消息是，我们现在可以重新创建is_valid一切！

5.2 重建is_valid

现在，我们已经有了一种非常时尚的方式，可以使用lambda生成具有潜在SFINAE属性的未命名类型，我们需要弄清楚如何使用它们！如您所见，hana :: is_valid是一个将lambda作为参数并返回类型的函数。我们将is_valid返回的类型称为container。container将负责保留lambda的未命名类型以供以后使用。让我们从编写is_valid函数及其container开始：

template <typename UnnamedType> struct container
{
    // Remembers UnnamedType.
};

template <typename UnnamedType> constexpr auto is_valid(const UnnamedType& t) 
{
    // We used auto for the return type: it will be deduced here.
    return container();
}

auto test = is_valid([](const auto& t) -> decltype(t.serialize()) {})
// Now 'test' remembers the type of the lambda and the signature of its operator()!

下一步是使用operator操作符()扩展容器，例如我们可以用一个参数调用它。此参数类型将针对UnnamedType进行测试!为了对参数类型进行测试，我们可以再次对一个重新创建的’UnnamedType’对象使用SFINAE !它给出了这个解决方案：

template <typename UnnamedType> struct container
{
// Let's put the test in private.
private:
    // We use std::declval to 'recreate' an object of 'UnnamedType'.
    // We use std::declval to also 'recreate' an object of type 'Param'.
    // We can use both of these recreated objects to test the validity!
    template <typename Param> constexpr auto testValidity(int /* unused */)
    -> decltype(std::declval()(std::declval()), std::true_type())
    {
        // If substitution didn't fail, we can return a true_type.
        return std::true_type();
    }

    template <typename Param> constexpr std::false_type testValidity(...)
    {
        // Our sink-hole returns a false_type.
        return std::false_type();
    }

public:
    // A public operator() that accept the argument we wish to test onto the UnnamedType.
    // Notice that the return type is automatic!
    template <typename Param> constexpr auto operator()(const Param& p)
    {
        // The argument is forwarded to one of the two overloads.
        // The SFINAE on the 'true_type' will come into play to dispatch.
        // Once again, we use the int for the precedence.
        return testValidity(int());
    }
};

template <typename UnnamedType> constexpr auto is_valid(const UnnamedType& t) 
{
    // We used auto for the return type: it will be deduced here.
    return container();
}

// Check if a type has a serialize method.
auto hasSerialize = is_valid([](auto&& x) -> decltype(x.serialize()) { });

如果您在这一点上有点困惑，我建议您花点时间重新阅读前面的所有示例。你已经拥有了所有你需要的武器，现在开始与c++战斗吧!

最后! ! !我们有一个工作是有效的，我们可以使用它的序列化!

如果我和我的SFINAE技巧一样邪恶，我会让你复制每个代码片段来重新创建一个完整的工作解决方案。但今天，万圣节的精神与我同在，这里是要点。嘿,嘿!不要这么快就结束这篇文章!如果你是真正的战士，你可以读最后一部分!

6.C++17

前面已经使用过这个方法了，这里提及一下即可。

7.For the fun

我没有告诉你几件事，是故意的。否则，我担心这篇文章要长两倍。我强烈建议您向Google询问有关我要说的内容的更多信息。

（1）首先，如果您希望有一个与Boost一起工作的解决方案。Boost.Hana static if_，您需要通过Hana的等效物来改变testValidity方法的返回类型，如下所示：

template <typename Param> constexpr auto test_validity(int /* unused */)
-> decltype(std::declval()(std::declval()), boost::hana::true_c)
{
    // If substitution didn't fail, we can return a true_type.
    return boost::hana::true_c;
}

template <typename Param> constexpr decltype(boost::hana::false_c) test_validity(...)
{
    // Our sink-hole returns a false_type.
    return boost::hana::false_c;
}

静态if实现非常有趣，但至少与我们在本文中解决的问题一样困难。也许有一天，我会再写一篇关于它的文章

（2）如果您注意到我们一次只检查一个参数？我们不能做这样的事情：

auto test = is_valid([](auto&& a, auto&& b) -> decltype(a.serialize(), b.serialize()) { });
A a;
B b;

std::cout << test(a, b) << std::endl;

实际上，我们可以使用一些参数包。这是解决方案：

template <typename UnnamedType> struct container
{
// Let's put the test in private.
private:
    // We use std::declval to 'recreate' an object of 'UnnamedType'.
    // We use std::declval to also 'recreate' an object of type 'Param'.
    // We can use both of these recreated objects to test the validity!
    template <typename... Params> constexpr auto test_validity(int /* unused */)
    -> decltype(std::declval()(std::declval()...), std::true_type())
    {
        // If substitution didn't fail, we can return a true_type.
        return std::true_type();
    }

    template <typename... Params> constexpr std::false_type test_validity(...)
    {
        // Our sink-hole returns a false_type.
        return std::false_type();
    }

public:
    // A public operator() that accept the argument we wish to test onto the UnnamedType.
    // Notice that the return type is automatic!
    template <typename... Params> constexpr auto operator()(Params&& ...)
    {
        // The argument is forwarded to one of the two overloads.
        // The SFINAE on the 'true_type' will come into play to dispatch.
        return test_validity(int());
    }
};

template <typename UnnamedType> constexpr auto is_valid(UnnamedType&& t)
{
    // We used auto for the return type: it will be deduced here.
    return container();
}

// Check if a type has a serialize method.
auto hasSerialize = is_valid([](auto &&x) -> decltype(x.serialize()) {});

// Notice how I simply swapped the return type on the right?
template<class T>
auto serialize(T &obj)
-> typename std::enable_if<decltype(hasSerialize(obj))::value, std::string>::type {
    return obj.serialize();
}

template<class T>
auto serialize(T &obj)
-> typename std::enable_if<!decltype(hasSerialize(obj))::value, std::string>::type {
    return to_string(obj);
}

int main() {
    A a;
    B b;
    C c;
    auto test = is_valid([](const auto &t) -> decltype(t.serialize()) {});

    std::cout << test(a,b) << std::endl;
    std::cout << test(b) << std::endl;
    std::cout << test(c) << std::endl;
    // The following lines work like a charm!
    std::cout << serialize(a) << std::endl;
    std::cout << serialize(b) << std::endl;
    std::cout << serialize(c) << std::endl;
}

8.总结

娜娜项目网每日更新创业和副业项目