C++17完整导引-模板特性之折叠表达式

最新推荐文章于 2024-09-07 15:04:17 发布
最新推荐文章于 2024-09-07 15:04:17 发布
阅读量904 收藏 1
点赞数 1
分类专栏： C++ 文章标签： c++ 算法 开发语言
本文原创作者：-西门吹雪 MMTS_yang
本文链接：https://blog.csdn.net/mmts_yang/article/details/130772965
版权

折叠表达式

自从C++17起，有一个新的特性可以计算对参数包中的 所有 参数应用一个二元运算符的结果。例如，下面的函数将会返回所有参数的总和：

template<typename... T>
auto foldSum (T... args) {
    return (... + args);    // ((arg1 + arg2) + arg3)...
}

注意返回语句中的括号是折叠表达式的一部分，不能被省略。如下调用：

foldSum(47, 11, val, -1);

会把模板实例化为：

return 47 + 11 + val + -1;

输出结果：

14

预处理代码如下：

#include <iostream>

using namespace std;

template<typename ... T>
auto foldSum(T... args)
{
  return (... + args);
}
#ifdef INSIGHTS_USE_TEMPLATE
template<>
int foldSum<int, int, int, int>(int __args0, int __args1, int __args2, int __args3)
{
  return ((__args0 + __args1) + __args2) + __args3;
}
#endif
int main()
{
  int val = 10;
  std::cout.operator<<(foldSum(2, 3, val, -1));
  return 0;
}

如下调用：

foldSum(std::string("hello"), "world", "!");

会把模板实例化为：

return std::string("hello") + "world" + "!";

运行结果如下：

helloworld!

预处理代码如下：

#include <iostream>
#include <string>

using namespace std;

template<typename ... T>
auto foldSum(T... args)
{
  return (... + args);
}
#ifdef INSIGHTS_USE_TEMPLATE
template<>
std::basic_string<char> foldSum<std::basic_string<char>, const char *, const char *>(std::basic_string<char> __args0, const char * __args1, const char * __args2)
{
  return std::operator+(std::operator+(__args0, __args1), __args2);
}
#endif
int main()
{
  std::operator<<(std::cout, foldSum(std::basic_string<char>(std::basic_string<char>("hello", std::allocator<char>())), "world", "!"));
  return 0;
}

注意折叠表达式里参数的位置很重要（可能看起来还有些反直觉）。如下写法：

(... + args)

会展开为：

((arg1 + arg2) + arg3) ...

这意味着折叠表达式会以“后递增式”重复展开。你也可以写：

(args + ...)

这样就会以“前递增式”展开，因此结果会变为：

//(arg1 + (arg2 + arg3)) ...
#include <iostream>
#include <string>

using namespace std;

template<typename ... T>
auto foldSum(T... args)
{
  return (args + ...);
}
#ifdef INSIGHTS_USE_TEMPLATE
template<>
int foldSum<int, int, int, int>(int __args0, int __args1, int __args2, int __args3)
{
  return __args0 + (__args1 + (__args2 + __args3));
}
#endif
int main()
{
  std::cout.operator<<(foldSum(47, 11, 1, -1));
  return 0;
}

动机

折叠表达式的出现让我们不必再用递归实例化模板的方式来处理参数包。在C++17之前，你必须这么实现：

template<typename T>
auto foldSumRec (T arg) {
    return arg;
}
template<typename T1, typename... Ts>
auto foldSumRec (T1 arg1, Ts... otherArgs) {
    return arg1 + foldSumRec(otherArgs...);
}

这样的实现不仅写起来麻烦，对C++编译器来说也很难处理。使用如下写法：

template<typename... T>
auto foldSum (T... args) {
    return (... + args);    // arg1 + arg2 + arg3...
}

能显著的减少程序员和编译器的工作量。

使用

给定一个参数 args 和一个操作符 op ，C++17允许我们这么写：

  • 一元左折叠

( ... op args )

将会展开为：((arg1 op arg2) op arg3) op ...

  • 一元右折叠

( args op ... )

将会展开为： arg1 op (arg2 op ... (argN-1 op argN))

括号是必须的，然而，括号和省略号(…)之间并不需要用空格分隔。

左折叠和右折叠的不同比想象中更大。例如，当你使用 + 时可能会产生不同的效果。使用左折叠时：

template<typename... T>
auto foldSumL(T... args) {
    return (... + args);    // ((arg1 + arg2) + arg3)...
}

如下调用

foldSumL(1, 2, 3);

会求值为

((1 + 2) + 3)

这意味着下面的例子能够通过编译：

std::cout << foldSumL(std::string("hello"), "world", "!") << '\n';  // OK

记住对字符串而言只有两侧至少有一个是std::string时才能使用+。使用左折叠时会首先计算

std::string("hello") + "world"

这将返回一个std::string，因此再加上字符串字面量"!"是有效的。然而，如下调用

std::cout << foldSumL("hello", "world", std::string("!")) << '\n';  // ERROR

将不能通过编译，因为它会求值为

("hello" + "world") + std::string("!");

然而把两个字符串字面量相加是错误的。
报错如下：

<source>: In instantiation of 'auto foldSum(T ...) [with T = {std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, const char*, const char*}]':
<source>:12:20:   required from here
<source>:8:20: error: invalid operands of types 'const char*' and 'const char*' to binary 'operator+'
    8 |     return (args + ...);    // ((arg1 + arg2) + arg3)...
      |            ~~~~~~~~^~~~

然而如果我们把实现修改为：

template<typename... T>
auto foldSumR(T... args) {
    return (args + ...);    // (arg1 + (arg2 + arg3))...
}

那么如下调用

foldSumR(1, 2, 3)

将求值为

(1 + (2 + 3))

这意味着下面的例子不能再通过编译：

std::cout << foldSumR(std::string("hello"), "world", "!") << '\n';  // ERROR

然而如下调用现在反而可以编译了：

std::cout << foldSumR("hello", "world", std::string("!")) << '\n';  // OK

在任何情况下，从左向右求值都是符合直觉的。因此，更推荐使用左折叠的语法：

(... + args);       // 推荐的折叠表达式语法

综合示例如下：

#include <iostream>
#include <string>

using namespace std;

template <typename... T>
auto foldSumL(T... args) {
    return (... + args);  // ((arg1 + arg2) + arg3)...
}
template <typename... T>
auto foldSumR(T... args) {
    return (args + ...);  // (arg1 + (arg2 + arg3))...
}
int main() {
    cout << foldSumL(std::string("hello"), "world", "!") << endl; // return std::operator+(std::operator+(__args0, __args1), __args2);
    cout << foldSumR("hello ", "world", std::string("!")) << endl; // return std::operator+(__args0, std::operator+(__args1, __args2));
    cout << foldSumL(1, 2, 3, 4) << endl; // return ((__args0 + __args1) + __args2) + __args3;
    cout << foldSumR(1, 2, 3, 4) << endl; //return __args0 + (__args1 + (__args2 + __args3));
    return 0;
}

运行结果

helloworld!
hello world!
10
10

预处理代码如下：

#include <iostream>
#include <string>

using namespace std;

template<typename ... T>
auto foldSumL(T... args)
{
  return (... + args);
}

#ifdef INSIGHTS_USE_TEMPLATE
template<>
std::basic_string<char> foldSumL<std::basic_string<char>, const char *, const char *>(std::basic_string<char> __args0, const char * __args1, const char * __args2)
{
  return std::operator+(std::operator+(__args0, __args1), __args2);
}
#endif


#ifdef INSIGHTS_USE_TEMPLATE
template<>
int foldSumL<int, int, int, int>(int __args0, int __args1, int __args2, int __args3)
{
  return ((__args0 + __args1) + __args2) + __args3;
}
#endif

template<typename ... T>
auto foldSumR(T... args)
{
  return (args + ...);
}


#ifdef INSIGHTS_USE_TEMPLATE
template<>
std::basic_string<char> foldSumR<const char *, const char *, std::basic_string<char> >(const char * __args0, const char * __args1, std::basic_string<char> __args2)
{
  return std::operator+(__args0, std::operator+(__args1, __args2));
}
#endif


#ifdef INSIGHTS_USE_TEMPLATE
template<>
int foldSumR<int, int, int, int>(int __args0, int __args1, int __args2, int __args3)
{
  return __args0 + (__args1 + (__args2 + __args3));
}
#endif

int main()
{
  std::operator<<(std::cout, foldSumL(std::basic_string<char>(std::basic_string<char>("hello", std::allocator<char>())), "world", "!")).operator<<(std::endl);
  std::operator<<(std::cout, foldSumR("hello ", "world", std::basic_string<char>(std::basic_string<char>("!", std::allocator<char>())))).operator<<(std::endl);
  std::cout.operator<<(foldSumL(1, 2, 3, 4)).operator<<(std::endl);
  std::cout.operator<<(foldSumR(1, 2, 3, 4)).operator<<(std::endl);
  return 0;
}

处理空参数包

当使用折叠表达式处理空参数包时，将遵循如下规则：

  • 如果使用了&&运算符，值为true。
  • 如果使用了||运算符，值为false。
  • 如果使用了逗号运算符，值为void()。
  • 使用所有其他的运算符，都会引发格式错误

对于所有其他的情况，你可以添加一个初始值：给定一个参数包 args ，一个初始值 value ，一个操作符 op ，C++17允许我们这么写：

  • 二元左折叠( value op ... op args )将会展开为：(((value op arg1) op arg2) op arg3) op ...
  • 二元右折叠( args op ... op value )将会展开为： arg1 op (arg2 op ... (argN op value)) 省略号两侧的 op 必须相同。

例如，下面的定义在进行加法时允许传递一个空参数包：

template<typename... T>
auto foldSum (T... s) {
    return (0 + ... + s);   // 即使sizeof...(s)==0也能工作
}

从概念上讲，不管0是第一个还是最后一个操作数应该和结果无关：

template<typename... T>
auto foldSum (T... s) {
    return (s + ... + 0);   // 即使sizeof...(s)==0也能工作
}

然而，对于一元折叠表达式来说，不同的求值顺序比想象中的更重要。对于二元表达式来说，也更推荐左折叠的方式：

(val + ... + args);         // 推荐的二元折叠表达式语法

有时候第一个操作数是特殊的，比如下面的例子：

template<typename... T>
void print (const T&... args)
{
    (std::cout << ... << args) << '\n';
}

这里，传递给print()的第一个参数输出之后将返回输出流，所以后面的参数可以继续输出。其他的实现可能不能编译或者产生一些意料之外的结果。例如，

std::cout << (args << ... << '\n');

类似print(1)的调用可以编译，但会打印出1左移'\n'位之后的值，'\n'的值通常是10，所以结果是1024。

注意在这个print()的例子中，两个参数之间没有输出空格字符。因此，如果调用print("hello", 42, "world")将会打印出：

hello42world

为了用空格分隔传入的参数，你需要一个辅助函数来确保除了第一个参数之外的剩余参数输出前都先输出一个空格。例如，使用如下的模板spaceBefore()可以做到这一点：

template<typename T>
const T& spaceBefore(const T& arg) {
    std::cout << ' ';
    return arg;
}

template <typename First, typename... Args>
void print (const First& firstarg, const Args&... args) {
    std::cout << firstarg;
    (std::cout << ... << spaceBefore(args)) << '\n';
}

这里，折叠表达式

(std::cout << ... << spaceBefore(args))

将会展开为：

std::cout << spaceBefore(arg1) << spaceBefore(arg2) << ...

因此，对于参数包中args的每一个参数，都会调用辅助函数，在输出参数之前先输出一个空格到std::cout。为了确保不会对第一个参数调用辅助函数，我们添加了额外的模板参数对第一个参数进行单独处理。
完整示例如下：

#include <iostream>
#include <string>

using namespace std;
template <typename T>
const T& spaceBefore(const T& arg) {
    std::cout << ' ';
    return arg;
}
template <typename... T>
void print(const T&... args) {
    (std::cout << ... << spaceBefore(args)) << '\n';
}
int main() {
    print(1);
    print("hello", 42, "world");
    return 0;
}

预处理代码如下：

#include <iostream>
#include <string>

using namespace std;

template<typename T>
const T & spaceBefore(const T & arg)
{
  std::operator<<(std::cout, ' ');
  return arg;
}
/* First instantiated from: insights.cpp:14 */
#ifdef INSIGHTS_USE_TEMPLATE
template<>
const int & spaceBefore<int>(const int & arg)
{
  std::operator<<(std::cout, ' ');
  return arg;
}
#endif

/* First instantiated from: insights.cpp:14 */
#ifdef INSIGHTS_USE_TEMPLATE
template<>
const char (&spaceBefore<char[6]>(const char (&arg)[6]))[6]
{
  std::operator<<(std::cout, ' ');
  return arg;
}
#endif


template<typename ... T>
void print(const T &... args)
{
  operator<<((std::cout << ... << spaceBefore(args)), '\n');
}


/* First instantiated from: insights.cpp:18 */
#ifdef INSIGHTS_USE_TEMPLATE
template<>
void print<int>(const int & __args0)
{
  std::operator<<(std::cout.operator<<(spaceBefore(__args0)), '\n');
}
#endif

/* First instantiated from: insights.cpp:19 */
#ifdef INSIGHTS_USE_TEMPLATE
template<>
void print<char[6], int, char[6]>(const char (&__args0)[6], const int & __args1, const char (&__args2)[6])
{
  std::operator<<(std::operator<<(std::operator<<(std::cout, spaceBefore(__args0)).operator<<(spaceBefore(__args1)), spaceBefore(__args2)), '\n');
}
#endif

int main()
{
  print(1);
  print("hello", 42, "world");
  return 0;
}

注意要想让参数包正确输出需要确保对每个参数调用spaceBefore()之前左侧的所有输出都已经完成。得益于操作符<<的有定义的求值顺序，自从C++17起将保证行为正确。

我们也可以使用lambda来在print()内定义spaceBefore()：

template<typename First, typename... Args>
void print (const First& firstarg, const Args&... args) {
    std::cout << firstarg;
    auto spaceBefore = [](const auto& arg) {
        std::cout << ' ';
        return arg;
    };
    (std::cout << ... << spaceBefore(args)) << '\n';
}

预处理代码如下:

#include <iostream>
#include <string>

using namespace std;

template<typename First, typename ... Args>
void print(const First & firstarg, const Args &... args)
{
  operator<<(std::cout, firstarg);
    
  class __lambda_9_24
  {
    public: 
    template<class type_parameter_1_0>
    inline auto operator()(const type_parameter_1_0 & arg) const
    {
      std::operator<<(std::cout, ' ');
      return arg;
    }
    private: 
    template<class type_parameter_1_0>
    static inline auto __invoke(const type_parameter_1_0 & arg)
    {
      return __lambda_9_24{}.operator()<type_parameter_1_0>(arg);
    }
    
    public:
    // /*constexpr */ __lambda_9_24() = default;
    
  };
  
  auto spaceBefore = __lambda_9_24{};
  operator<<((std::cout << ... << spaceBefore(args)), '\n');
}


/* First instantiated from: insights.cpp:17 */
#ifdef INSIGHTS_USE_TEMPLATE
template<>
void print<int>(const int & firstarg)
{
  std::cout.operator<<(firstarg);
    
  class __lambda_9_24
  {
    public: 
    template<class type_parameter_0_0>
    inline /*constexpr */ auto operator()(const type_parameter_0_0 & arg) const
    {
      std::operator<<(std::cout, ' ');
      return arg;
    }
    private: 
    template<class type_parameter_0_0>
    static inline /*constexpr */ auto __invoke(const type_parameter_0_0 & arg)
    {
      return __lambda_9_24{}.operator()<type_parameter_0_0>(arg);
    }
    
    public:
    // /*constexpr */ __lambda_9_24() = default;
    
  };
  
  __lambda_9_24 spaceBefore = __lambda_9_24{};
  std::operator<<(std::cout, '\n');
}
#endif


/* First instantiated from: insights.cpp:18 */
#ifdef INSIGHTS_USE_TEMPLATE
template<>
void print<char[6], int, char[6]>(const char (&firstarg)[6], const int & __args1, const char (&__args2)[6])
{
  std::operator<<(std::cout, firstarg);
    
  class __lambda_9_24
  {
    public: 
    template<class type_parameter_0_0>
    inline /*constexpr */ auto operator()(const type_parameter_0_0 & arg) const
    {
      std::operator<<(std::cout, ' ');
      return arg;
    }
    
    #ifdef INSIGHTS_USE_TEMPLATE
    template<>
    inline /*constexpr */ int operator()<int>(const int & arg) const
    {
      std::operator<<(std::cout, ' ');
      return arg;
    }
    #endif
    
    
    #ifdef INSIGHTS_USE_TEMPLATE
    template<>
    inline /*constexpr */ const char * operator()<char[6]>(const char (&arg)[6]) const
    {
      std::operator<<(std::cout, ' ');
      return arg;
    }
    #endif
    
    private: 
    template<class type_parameter_0_0>
    static inline /*constexpr */ auto __invoke(const type_parameter_0_0 & arg)
    {
      return __lambda_9_24{}.operator()<type_parameter_0_0>(arg);
    }
    
    public:
    // /*constexpr */ __lambda_9_24() = default;
    
  };
  
  __lambda_9_24 spaceBefore = __lambda_9_24{};
  std::operator<<(std::operator<<(std::cout.operator<<(spaceBefore.operator()(__args1)), spaceBefore.operator()(__args2)), '\n');
}
#endif


int main()
{
  print(1);
  print("hello", 42, "world");
  return 0;
}

然而，注意默认情况下lambda以值返回对象，这意味着会创建参数的不必要的拷贝。解决方法是显式指明返回类型为const auto&或者decltype(auto)：

template<typename First, typename... Args>
void print (const First& firstarg, const Args&... args) {
    std::cout << firstarg;
    auto spaceBefore = [](const auto& arg) -> const auto& {
        std::cout << ' ';
        return arg;
    };
    (std::cout << ... << spaceBefore(args)) << '\n';
}

如果你不能把它们写在一个表达式里那么C++就不是C++了：

template<typename First, typename... Args>
void print (const First& firstarg, const Args&... args) {
    std::cout << firstarg;
    (std::cout << ... << [] (const auto& arg) -> decltype(auto) {
                             std::cout << ' ';
                             return arg;
                         }(args)) << '\n';
}

不过，一个更简单的实现print()的方法是使用一个lambda输出空格和参数，然后在一元折叠表达式里使用它：

template<typename First, typename... Args>
void print(First first, const Args&... args) {
    std::cout << first;
    auto outWithSpace = [] (const auto& arg) {
                            std::cout << ' ' << arg;
                        };
    (... , outWithSpace(args));
    std::cout << '\n';
}

通过使用新的auto模板参数，我们可以使print()变得更加灵活：可以把间隔符定义为一个参数，这个参数可以是一个字符、一个字符串或者其它任何可打印的类型。

支持的运算符

你可以对除了.、->、[]之外的所有二元运算符使用折叠表达式。

折叠函数调用

折叠表达式可以用于逗号运算符，这样就可以在一条语句里进行多次函数调用。也就是说，你现在可以简单写出如下实现：

template<typename... Types>
void callFoo(const Types&... args)
{
    ...
    (... , foo(args));  // 调用foo(arg1)，foo(arg2)，foo(arg3)，...
}

来对所有参数调用函数foo()。

另外，如果需要支持移动语义：

template<typename... Types>
void callFoo(Types&&... args)
{
    ...
    (... , foo(std::forward<Types>(args))); // 调用foo(arg1)，foo(arg2)，...
}

如果foo()函数返回的类型重载了逗号运算符，那么代码行为可能会改变。为了保证这种情况下代码依然安全，你需要把返回值转换为void：

template<typename... Types>
void callFoo(const Types&... args)
{
    ...
    (... , (void)foo(std::forward<Types>(args))); // 调用foo(arg1)，foo(arg2)，...
}

注意自然情况下，对于逗号运算符不管我们是左折叠还是右折叠都是一样的。函数调用们总是会从左向右执行。如下写法：

(foo(args) , ...);

中的括号只是把后边的调用括在一起，因此首先是第一个foo()调用，之后是被括起来的两个foo()调用：

foo(arg1) , (foo(arg2) , foo(arg3));

然而，因为逗号表达式的求值顺序通常是自左向右，所以第一个调用通常发生在括号里的两个调用之前，并且括号里左侧的调用在右侧的调用之前。不过，因为左折叠更符合自然的求值顺序，因此在使用折叠表达式进行多次函数调用时还是推荐使用左折叠。

组合哈希函数

可以用如下的方法完成组合哈希函数：

template<typename T>
void hashCombine (std::size_t& seed, const T& val)
{
    seed ^= std::hash<T>()(val) + 0x9e3779b9 + (seed<<6) + (seed>>2);
}

template<typename... Types>
std::size_t combinedHashValue (const Types&... args)
{
    std::size_t seed = 0;               // 初始化seed
    (... , hashCombine(seed, args));    // 链式调用hashCombine()
    return seed;
}

如下调用

combinedHashValue ("Hi", "World", 42);

函数中的折叠表达式将被展开为：

hashCombine(seed, "Hi"), (hashCombine(seed, "World"), hashCombine(seed, 42));

有了这些定义，我们现在可以轻易的定义出一个新的哈希函数，并将这个函数用于某一个类型例如Customer的unordered set或unordered map：

struct CustomerHash
{
    std::size_t operator() (const Customer& c) const {
        return combinedHashValue(c.getFirstname(), c.getLastname(), c.getValue());
    }
};

std::unordered_set<Customer, CustomerHash> coll;
std::unordered_map<Customer, std::string, CustomerHash> map;

折叠基类的函数调用

例如，折叠逗号表达式来调用可变数量基类的成员函数：

#include <iostream>

// 可变数量基类的模板
template <typename... Bases>
class MultiBase : private Bases... {
   public:
    void print() {
        // 调用所有基类的print()函数
        (..., Bases::print());
    }
};

struct A {
    void print() { std::cout << "A::print()\n"; }
};

struct B {
    void print() { std::cout << "B::print()\n"; }
};

struct C {
    void print() { std::cout << "C::print()\n"; }
};

int main() {
    MultiBase<A, B, C> mb;
    mb.print();
}

运行结果：

A::print()
B::print()
C::print()

这里

template<typename... Bases>
class MultiBase : private Bases...
{
    ...
};

允许我们用可变数量的基类初始化对象：

MultiBase<A, B, C> mb;

之后，通过

(... , Bases::print());

这个折叠表达式将展开为调用每一个基类中的print。也就是说，这条语句会被展开为如下代码：

(A::print(), B::print()), C::print();

预处理代码如下：

#include <iostream>

// 可变数量基类的模板
template<typename ... Bases>
class MultiBase : private Bases...
{
  
  public: 
  inline void print()
  {
    (... , Bases::print());
  }
  
};
/* First instantiated from: insights.cpp:26 */
#ifdef INSIGHTS_USE_TEMPLATE
template<>
class MultiBase<A, B, C> : private A, private B, private C
{
  public: 
  inline void print()
  {
    (/* static_cast<A *>(this)-> */ print() , /* static_cast<B *>(this)-> */ print()) , /* static_cast<C *>(this)-> */ print();
  }
  
  // inline constexpr MultiBase() noexcept = default;
};

#endif
struct A
{
  inline void print()
  {
    std::operator<<(std::cout, "A::print()\n");
  }
  
  // inline constexpr A() noexcept = default;
};

struct B
{
  inline void print()
  {
    std::operator<<(std::cout, "B::print()\n");
  }
  
  // inline constexpr B() noexcept = default;
};

struct C
{
  inline void print()
  {
    std::operator<<(std::cout, "C::print()\n");
  }
  
  // inline constexpr C() noexcept = default;
};

int main()
{
  MultiBase<A, B, C> mb = MultiBase<A, B, C>();
  mb.print();
  return 0;
}

折叠路径遍历

你也可以使用折叠表达式通过运算符->\*遍历一个二叉树中的路径。
考虑下面的递归数据结构：

// 定义二叉树结构和遍历辅助函数
struct Node {
    int value;
    Node *subLeft{nullptr};
    Node *subRight{nullptr};
    Node(int i = 0) : value{i} {
    }
    int getValue() const {
        return value;
    }
    ...
    // 遍历辅助函数：
    static constexpr auto left = &Node::subLeft;
    static constexpr auto right = &Node::subRight;

    // 使用折叠表达式遍历树：
    template<typename T, typename... TP>
    static Node* traverse(T np, TP... paths) {
        return (np ->* ... ->* paths);  // np ->* paths1 ->* paths2
    }
};

这里，

(np ->* ... ->* paths)

使用了折叠表达式以np为起点遍历可变长度的路径，可以像下面这样使用这个函数：

#include "foldtraverse.hpp"
#include <iostream>

int main()
{
    // 初始化二叉树结构：
    Node* root = new Node{0};
    root->subLeft = new Node{1};
    root->subLeft->subRight = new Node{2};
    ...
    // 遍历二叉树：
    Node* node = Node::traverse(root, Node::left, Node::right);
    std::cout << node->getValue() << '\n';
    node = root ->* Node::left ->* Node::right;
    std::cout << node->getValue() << '\n';
    node = root -> subLeft -> subRight;
    std::cout << node->getValue() << '\n';
}

当调用

Node::traverse(root, Node::left, Node::right);

时折叠表达式将展开为：

root ->* Node::left ->* Node::right

结果等价于

root -> subLeft -> subRight

预处理代码如下：

#include <iostream>

struct Node
{
  int value;
  Node * subLeft;
  Node * subRight;
  inline Node(int i)
  : value{i}
  , subLeft{nullptr}
  , subRight{nullptr}
  {
  }
  
  inline int getValue() const
  {
    return this->value;
  }
  
  using MemberVarPtr_9 = Node *Node::*;
  inline static constexpr MemberVarPtr_9 left = &subLeft;
  using MemberVarPtr_10 = Node *Node::*;
  inline static constexpr MemberVarPtr_10 right = &subRight;
  template<typename T, typename ... TP>
  static inline Node * traverse(T np, TP... paths)
  {
    return (np ->* ... ->* paths);
  }
  
  /* First instantiated from: insights.cpp:23 */
  #ifdef INSIGHTS_USE_TEMPLATE
  template<>
  static inline Node * traverse<Node *, Node *Node::*, Node *Node::*>(Node * np, Node *Node::* __paths1, Node *Node::* __paths2)
  {
    return (np ->* __paths1) ->* __paths2;
  }
  #endif
};

int main()
{
  Node * root = new Node{0};
  root->subLeft = new Node{1};
  root->subLeft->subRight = new Node{2};
  Node * node = Node::traverse(root, Node::left, Node::right);
  std::operator<<(std::cout.operator<<(node->getValue()), '\n');
  node = ((root ->* Node::left) ->* Node::right);
  std::operator<<(std::cout.operator<<(node->getValue()), '\n');
  node = root->subLeft->subRight;
  std::operator<<(std::cout.operator<<(node->getValue()), '\n');
  return 0;
}

使用折叠表达式处理类型

通过使用类型特征，我们也可以使用折叠表达式来处理模板参数包（任意数量的模板类型参数）。例如，你可以使用折叠表达式来判断一些类型是否相同：

#include <type_traits>

// 检查是否所有类型都相同：
template<typename T1, typename... TN>
struct IsHomogeneous {
    static constexpr bool value = (std::is_same_v<T1, TN> && ...);
};

// 检查是否所有传入的参数类型相同：
template<typename T1, typename... TN>
constexpr bool isHomogeneous(T1, TN...)
{
    return (std::is_same_v<T1, TN> && ...);
}

类型特征IsHomogeneous<>可以像下面这样使用：

IsHomogeneous<int, MyType, decltype(42)>::value

这种情况下，折叠表达式将会展开为：

std::is_same_v<int, MyType> && std::is_same_v<int, decltype(42)>

函数模板isHomogeneous<>()可以像下面这样使用：

isHomogeneous(43, -1, "hello", nullptr)

在这种情况下，折叠表达式将会展开为：

std::is_same_v<int, int> && std::is_same_v<int, const char*> && is_same_v<int, std::nullptr_t>

像通常一样，运算符&&会短路求值（出现第一个false时就会停止运算）。标准库里std::array<>的推导指引就使用了这个特性。

C++(17)：折叠表达式
风静如云的博客
06-30 1082
C++17对可变长模板参数引入了折叠表达式，以简化对参数包的处理，也可以避免递归调用。C++17前如果想实现一个可变长参数相加，需要这样实现： C++17的折叠表达式通过简化的方式实现这个功能：.........
C++ 新特性 | C++17 常用新特性介绍
dvlinker的技术专栏
08-09 6921
本文详细介绍一下C++17的常用新特性。
C++17之折叠表达式
红军不怕远征难，万水千山只等闲
02-26 1603
折叠表达式是一个强大的工具，但也需要谨慎使用。它可以使代码更简洁、更易于阅读，但也可能会使代码更难以理解。在使用折表达式之前，确保你理解了它的工作原理，并考虑是否有其他更直观的方法可以达到相同的效果。
C++基础：折叠表达式（C++17）
最新发布
qq_73143395的博客
09-07 580
C++17 引入了一种新的语法特性，叫做折叠表达式，它允许编译器在模板参数包展开时进行元编程操作。折叠表达式的引入极大地简化了元编程代码，使其变得更为直观和简介。
c++17 折叠表达式
qq_38409301的博客
01-02 932
转载： C++17之『折叠表达式』_buknow的博客-CSDN博客 重点： 1.使用折叠表达式可以简化对C++11中引入的参数包的处理。 2.根据参数包的位置分为左折叠和右折叠, 3. 点在参数左边叫左折叠（...+t），点在参数右边叫右折叠(t+...) 4.根据操作的对象数量分为一元折叠和二元折叠. 5.左折叠和右折叠并不相同，加法和乘法的时候相同，减法和除法则不同 一：左折叠 1.一元左折叠 空参数会报错。 采用二元折叠，就是必须要有一个初始值，对于加法来说采用0.
C++17折叠表达式（Fold Expressions）
记录值得记录的东西
11-20 372
1
C++17中的折叠表达式实现
01-19
但在 C++11中展开参数包稍显麻烦, 而 C++17 的折叠表达式使得展开参数包变得容易, 其基本语法是使用 (…) 的语法形式进行展开。 支持的操作符 C++17中，折叠表达式支持 32 个操作符: +, -, *, /, %, ^, &, |, =,...
折叠表达式C++17
__WindRises_的博客
01-17 1113
template&lt;class T&gt; auto unary_left_fold(T ...args){ // op(op(op(1,2),3),4) // op: +, -, *, /, %, ^, &amp;, |, &lt;&lt;, &gt;&gt;, // =, +=, -=, *=, /=, %=, ^=, &amp;=, |=, &lt;&l...
C++11新特性：Lambda表达式.pdf
10-20
C++11新特性：Lambda表达式 Lambda表达式是C++11新特性中的一种，全新的特性听起来很深奥，但却是很多其他语言早已提供（比如C#）或者即将提供（比如Java）的。Lambda表达式就是用于创建匿名函数的，GCC 4.5.x和...
C++17 之 "折叠表达式"
ding_yingzi的博客
04-17 8443
支持的操作符 折叠分类 空参数包 其它例子 最后 C++11 提供了可变模板参数包, 使函数可以接受任意数量的参数. 但在 C++11 中展开参数包稍显麻烦, 而 C++17 的折叠表达式使得展开参数包变得容易, 其基本语法是使用 (...) 的语法形式进行展开. 支持的操作符 折叠表达式支持 32 个操作符: +, -, *, /, %, ^, &amp;, |, =,...
跟我学c++中级篇——c++17中的折叠表达式
fpcc的专栏
12-16 2212
对C++17中的折叠表达式进行分析说明
C++17 fold expression
Dablelv 的博客专栏。
08-28 4049
C++11 增加了一个新特性变参模板（variadic template），它可以接受任意个模版参数，参数包不能直接展开，需要通过一些特殊的方法，比如函数参数包的展开可以使用递归方式或逗号表达式，在使用的时候有点难度。C++17 解决了这个问题，通过折叠表达式（fold expression）简化对参数包的展开。
C++(17)：折叠表达式的使用
风静如云的博客
06-30 688
1.通过折叠表达式可以更为轻松的判断所有表达式是否都为true，或者部分为true 当然这种方式有个缺点，就是原先&&和||的熔断方式，通过这种方式调用时将不再存在： 可以看到，不论前面的表达是是true还是false，allTrue和anyTrue都会对一个参数进行求值。2.混合输出： 可见对于在运算时还可以对En施加以函数。上例中的(... , fn(mXs))展开后相当于：((fn(E1) , fn(E2)) , ...) , fn(EN).........
C++17编程之 折叠表达式
Awesomewan的博客
03-16 980
折叠表达式是一种新的语言特性，它使得可以对包含若干个参数的可变参数模板进行操作，同时将其所有参数合并成一个值。比如，如果你用减法或除法作为一元右折叠的操作符，那么你得到的结果可能和你预期的不一样。（4）当一元折叠表达式中的参数包为空时，只有三个运算符（&& || 以及逗号）有缺省值，其中&&的缺省值为true,||的缺省值为false，逗号的缺省值为void()。（3）初始值在右边的为右折叠，展开之后从右边开始折叠。折叠表达式共有四种语法形式，分别为一元的左折叠和右折叠，以及二元的左折叠和右折叠。
C++17特性：折叠表达式
qq_32885471的博客
05-27 1061
C++17新增了一个特性用于对参数列表中所有实参应用二元操作符并计算结果。注意，返回表达式两边的括号是折叠表达式的一部分，不能省略。还要注意折叠表达式参数顺序的不同有不同的效果：比如写成则结果为意味着它是重复地往后相加。还可以写成。
C++17尝鲜：fold expression（折叠表达式）
热门推荐
zwvista的专栏
01-02 1万+
折叠表达式
C++17折叠表达式的用法
a4364634611的博客
04-03 624
今天写了写这方面的东西，发现文章比较少，就决定写一写。 想要知道折叠表达式是什么，我们得知道什么是可变参数，可变参数模板，在c++17之前，c++11，我们的可变参数模板都是使用递归解包，过于消耗资源且不方便，我们举几个例子吧 #include<iostream> //设置退出条件 void show(){} template<typename T,typename ...Args> void show(T v, Args... args) { std::cout <&
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

-西门吹雪

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值