Сложите одиннадцатый диапазон новых функций в С++ 23

1. Введение

Свернуть, свернуть, это то же самое, что и выражение fold в C++17, проанализированное ранее. Просто в Рейнджах флуд станет сильнее. Но, если честно, большинство разработчиков, впервые соприкоснувшихся с этим, могут растеряться. В конце концов, он используется иначе, чем традиционно понимается. Люди больше подходят для прямой, обратной или фрагментарной обработки, которые легко понять, но это свертывание немного отличается. Это рекурсивная обработка блока (пока это разрешено) для выполнения какой-либо операции (или алгоритмической логики).

Два, кратный алгоритм

В С++ 23 учитывается Fold в левом и правом направлениях, что очень удобно для приложения в Ranges.Преимущество алгоритма fold в том, что он может игнорировать тип начального значения. Например, начальное значение — int, затем, если вычисление двойное, исходный std::accumulate возвращает int. В то же время некоторые из этих алгоритмов свертки используют std::Optional.Если входная вычислительная единица имеет нулевое значение, это легче отразить, то есть повысить безопасность, в то время как другие, такие как Max, могут иметь поведение UB.
Конечно, преобразование между левым и правым можно реализовать и самому, то есть использовать views::reverse для работы, разумеется, операнды тоже нужно обменивать самому.

3. Применение

В c++STL, если вы использовали разработчиков std::accumulate, в основном лучше понять, что накопление сложения на самом деле является формой рекурсии. Взгляните на его реализацию:

// accmulate原型
template<class  _Init,
	class _Ty,
	class _Fn2> inline
	_Ty _Accmulate(_Init _First, _Init _Last, _Ty _Val, _Fn2 _Func)
{
	for (; _First != _Last; ++_First) {
		// _Func为回调函数
		_Val = _Func(_Val, * _First);
	}

	return _Val;
}

В С++ 23 предусмотрены следующие складки:

ranges::fold_right_last：left-folds a range of elements
ranges::fold_left：right-folds a range of elements
ranges::fold_left_first：right-folds a range of elements using the last element as an initial value
ranges::fold_left_with_iter：left-folds a range of elements, and returns a pair (iterator, value)
ranges::fold_left_first_with_iter：left-folds a range of elements using the first element as an initial value, and returns a pair (iterator, optional)

Есть две более ранние, накапливать и уменьшать (С++ 17).Вы можете узнать их функции через приведенные выше функции, см. одну из подпрограмм:

#include <algorithm>
#include <functional>
#include <iostream>
#include <ranges>
#include <string>
#include <utility>
#include <vector>
using namespace std::literals;

int main()
{
    auto v = {1, 2, 3, 4, 5, 6, 7, 8};
    std::vector<std::string> vs {"A", "B", "C", "D"};

    auto r1 = std::ranges::fold_right(v.begin(), v.end(), 6, std::plus<>()); // (1)
    std::cout << "r1: " << r1 << '\n';

    auto r2 = std::ranges::fold_right(vs, "!"s, std::plus<>()); // (2)
    std::cout << "r2: " << r2 << '\n';

    // Use a program defined function object (lambda-expression):
    std::string r3 = std::ranges::fold_right
    (
        v, "A", [](int x, std::string s) { return s + ':' + std::to_string(x); }
    );
    std::cout << "r3: " << r3 << '\n';

    // Get the product of the std::pair::second of all pairs in the vector:
    std::vector<std::pair<char, float>> data {
   
   {'A', 2.f}, {'B', 3.f}, {'C', 3.5f}};
    float r4 = std::ranges::fold_right
    (
        data | std::ranges::views::values, 2.0f, std::multiplies<>()
    );
    std::cout << "r4: " << r4 << '\n';
}

результат операции:

r1: 42
r2: ABCD!
r3: A:8:7:6:5:4:3:2:1
r4: 42

Дополнительную информацию можно найти по адресу:
https://zh.cppreference.com/w/cpp/algorithm/ranges/fold_right
https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2022/p2322r6 . .html

4. Резюме

Короче говоря, бесспорным фактом является то, что стандарт C++ постоянно развивается в сторону простоты и мощных функций. Но как эта эволюция в конечном итоге будет выглядеть, трудно сказать. Однако с этого года C++ снова возродился, превзойдя Java и догнав C, надеясь сохранить его. ChagGpt не так мощен, как предполагалось, и можно ожидать будущего C++.