很久没有上博客园了，最近一段时间，因为工作的关系时间上比较闲，利用闲暇时间重新翻了一下丢弃很久的C++语言。C++从98、11、14、17目前已经也走到了20版本，发生了很多变化，也引入了很多新的语言特性和库，让开发也更加的便、高效。
但用惯了Java后，发现其中Java的容器流式操作特别简单，封装的很是优雅。而在C++中，针对容器的操作，与算法是完全分隔的，操作起来利用迭代器进行串接，这种方式其实本身实际上复用效率特别高效，但是对于开发者来说，又显得有些低效，考虑到这个问题，我自己对C++的容器与算法，简单做了一个封装。
话不多说，直接上代码，让大家看看效果！
示例代码
vector<int> vec = {1, 3, 4, 6, 4, 2, 11, 9};
auto minmax = JavaStyleStream<vector, int>(vec)
.filter([](int i) { return i % 3 == 0; })
.transform([](int i){return i*2.5;})
.sort()
.for_each([](double i) { std::cout << i << " ";})
.minmax();
cout << minmax.first << ":" << minmax.second << endl;
最终结果
7.5 15 22.5 7.5:22.5
看到这里，是不是觉得容器操作起来要高效很多，不用再面对一成不变的迭代器了。
详细的Java Style容器流式封装类，见下面代码（未完整封装C++所有算法，工作还在进行中）,觉得好用，麻烦点个赞，也欢迎大家提出宝贵意见
//
// Created by AILI on 2022/10/6.
//
#ifndef CPPTEST_JAVASTYLESTREAM_H
#define CPPTEST_JAVASTYLESTREAM_H
#include <algorithm>
#include "function_traits.h"
//template <template<typename, typename> class Cont>
//struct Stream {};
template<template<typename T1, typename T2> class Cont, typename Tp, typename Alloc = std::allocator<Tp>>
class JavaStyleStream {
public:
typedef typename Cont<Tp, Alloc>::value_type value_type;
typedef typename Cont<Tp, Alloc>::pointer pointer;
typedef typename Cont<Tp, Alloc>::const_pointer const_pointer;
typedef typename Cont<Tp, Alloc>::reference reference;
typedef typename Cont<Tp, Alloc>::const_reference const_reference;
typedef typename Cont<Tp, Alloc>::iterator iterator;
typedef typename Cont<Tp, Alloc>::const_iterator const_iterator;
typedef typename Cont<Tp, Alloc>::const_reverse_iterator const_reverse_iterator;
typedef typename Cont<Tp, Alloc>::reverse_iterator reverse_iterator;
typedef typename Cont<Tp, Alloc>::size_type size_type;
typedef typename Cont<Tp, Alloc>::difference_type difference_type;
typedef typename Cont<Tp, Alloc>::allocator_type allocator_type;
//聚合
value_type max() {
return *max_element();
}
template<typename _Compare>
value_type max(_Compare compare) {
return *max_element();
}
iterator max_element() {
return std::max_element(_container.begin(), _container.end());
}
template<typename _Compare>
iterator max_element(_Compare compare) {
return std::max_element(_container.begin(), _container.end(), compare);
}
value_type min() {
return *min_element();
}
template<typename _Compare>
value_type min(_Compare compare) {
return *min_element(compare);
}
iterator min_element() {
return std::min(_container.begin(), _container.end());
}
template<typename _Compare>
iterator min_element(_Compare compare) {
return std::min(_container.begin(), _container.end(), compare);
}
pair<value_type, value_type> minmax() {
pair<const_iterator, const_iterator> r = minmax_element();
return pair<value_type, value_type>(*(r.first), *(r.second));
}
pair<const_iterator, const_iterator> minmax_element() {
return std::minmax_element(_container.begin(), _container.end());
}
template<typename _Compare>
pair<const_iterator, const_iterator> minmax_element(_Compare compare) {
return std::minmax_element(_container.begin(), _container.end(), compare);
}
difference_type count(const value_type& value) {
return std::count(_container.begin(), _container.end(), value);
}
template<typename _Predicate>
difference_type count_if(_Predicate predicate) {
return std::count_if(_container.begin(), _container.end(), predicate);
}
//查找
template<typename _Predicate>
bool all_of(_Predicate predicate) {
return std::all_of(_container.begin(), _container.end(), predicate);
}
template<typename _Predicate>
bool any_of(_Predicate predicate) {
return std::any_of(_container.begin(), _container.end(), predicate);
}
template<typename _Predicate>
bool none_of(_Predicate predicate) {
return std::none_of(_container.begin(), _container.end(), predicate);
}
iterator adjacent_find() {
return std::adjacent_find(_container.begin(), _container.end());
}
template<typename _BinaryPredicate>
iterator adjacent_find(_BinaryPredicate predicate) {
return std::adjacent_find(_container.begin(), _container.end(), predicate);
}
iterator find(const value_type& value) {
return std::find(_container.begin(), _container.end(), value);
}
template<typename _Predicate>
iterator find_if(_Predicate predicate) {
return std::find_if(_container.begin(), _container.end(), predicate);
}
iterator find_first_of(iterator find_begin, iterator find_end) {
return std::find_first_of(_container.begin(), _container.end(), find_begin, find_end);
}
template<typename _BinaryPredicate>
iterator find_first_of(iterator find_begin, iterator find_end, _BinaryPredicate predicate) {
return std::find_first_of(_container.begin(), _container.end(), find_begin, find_end, predicate);
}
iterator find_end(iterator find_begin, iterator find_end) {
return std::find_end(_container.begin(), _container.end(), find_begin, find_end);
}
template<typename _BinaryPredicate>
iterator find_end(iterator find_begin, iterator find_end, _BinaryPredicate predicate) {
return std::find_end(_container.begin(), _container.end(), find_begin, find_end, predicate);
}
iterator binary_search(const value_type& value) {
return std::binary_search(_container.begin(), _container.end(), value);
}
template<typename _Compare>
iterator binary_search(const value_type& value, _Compare compare) {
return std::binary_search(_container.begin(), _container.end(), value, compare);
}
iterator search(const value_type& value) {
return std::search(_container.begin(), _container.end(), value);
}
template<typename _BinaryPredicate>
iterator search(iterator find_begin, iterator find_end, _BinaryPredicate predicate) {
return std::search(_container.begin(), _container.end(), find_begin, find_end, predicate);
}
iterator search_n(size_type n, const value_type& value) {
return std::search_n(_container.begin(), _container.end(), n, value);
}
template<typename _BinaryPredicate>
iterator search_n(size_type n, const value_type& value, _BinaryPredicate predicate) {
return std::search_n(_container.begin(), _container.end(), n, value, predicate);
}
iterator lower_bound(const value_type& value) {
return std::lower_bound(_container.begin(), _container.end(), value);
}
template<typename _Compare>
iterator lower_bound(const value_type& value, _Compare compare) {
return std::lower_bound(_container.begin(), _container.end(), value, compare);
}
iterator upper_bound(const value_type& value) {
return std::upper_bound(_container.begin(), _container.end(), value);
}
template<typename _Compare>
iterator upper_bound(const value_type& value, _Compare compare) {
return std::upper_bound(_container.begin(), _container.end(), value, compare);
}
//排序
bool is_sorted() {
return std::is_sorted(_container.begin(), _container.end());
}
template<typename _Compare>
bool is_sorted(_Compare compare) {
return std::is_sorted(_container.begin(), _container.end(), compare);
}
bool is_sorted_until() {
return std::is_sorted_until(_container.begin(), _container.end());
}
template<typename _Compare>
bool is_sorted_until(_Compare compare) {
return std::is_sorted_until(_container.begin(), _container.end(), compare);
}
JavaStyleStream& sort() {
std::sort(_container.begin(), _container.end());
return *this;
}
template<typename _Compare>
JavaStyleStream& sort(_Compare compare) {
std::sort(_container.begin(), _container.end(), compare);
return *this;
}
template<typename _Integer>
JavaStyleStream& partial_sort(_Integer integer) {
std::partial_sort(_container.begin(), _container.begin() + integer, _container.end());
return *this;
}
template<typename _Integer, typename _Compare>
JavaStyleStream& partial_sort(_Integer integer, _Compare compare) {
std::partial_sort(_container.begin(), _container.begin() + integer, _container.end(), compare);
return *this;
}
JavaStyleStream& stable_sort() {
std::stable_sort(_container.begin(), _container.end());
return *this;
}
template<typename _Compare>
JavaStyleStream& stable_sort(_Compare compare) {
std::stable_sort(_container.begin(), _container.end(), compare);
return *this;
}
template<typename _Integer>
JavaStyleStream& nth_element(_Integer integer) {
std::nth_element(_container.begin(), _container.begin() + integer, _container.end());
return *this;
}
template<typename _Integer, typename _Compare>
JavaStyleStream& nth_element(_Integer integer, _Compare compare) {
std::nth_element(_container.begin(), _container.begin() + integer, _container.end(), compare);
return *this;
}
JavaStyleStream& shuffle() {
std::shuffle(_container.begin(), _container.end());
return *this;
}
template<typename _Generator>
JavaStyleStream& shuffle(_Generator generator) {
std::shuffle(_container.begin(), _container.end(), generator);
return *this;
}
JavaStyleStream& random_shuffle() {
std::random_shuffle(_container.begin(), _container.end());
return *this;
}
template<typename _Generator>
JavaStyleStream& random_shuffle(_Generator generator) {
std::random_shuffle(_container.begin(), _container.end(), generator);
return *this;
}
//删除&替换
JavaStyleStream& remove_erase(const value_type& value) {
_container.erase(std::remove(_container.begin(), _container.end(), value), _container.end());
return *this;
}
template<typename _Predicate>
JavaStyleStream& remove_erase(_Predicate predicate) {
_container.erase(std::remove_if(_container.begin(), _container.end(), predicate), _container.end());
return *this;
}
JavaStyleStream& repalce(const value_type& old_value, const value_type& new_value) {
std::replace(_container.begin(), _container.end(), old_value, new_value);
return *this;
}
template<typename _Predicate>
JavaStyleStream& replace_if(_Predicate predicate, const value_type& new_value) {
std::remove_if(_container.begin(), _container.end(), predicate, new_value);
return *this;
}
//反转&旋转
JavaStyleStream& reverse() {
std::reverse(_container.begin(), _container.end());
return *this;
}
template<typename _Integer>
JavaStyleStream& reverse(_Integer integer) {
std::rotate(_container.begin(), _container.begin() + integer, _container.end());
return *this;
}
//归一化
JavaStyleStream& unique() {
std::unique(_container.begin(), _container.end());
return *this;
}
template<typename _BinaryPredicate>
JavaStyleStream& unique(_BinaryPredicate predicate) {
std::unique(_container.begin(), _container.end(), predicate);
return *this;
}
//分组(是否需要返回分组迭代器？）
template<typename _Predicate>
JavaStyleStream& partition(_Predicate predicate) {
std::partition(_container.begin(), _container.end(), predicate);
return *this;
}
template<typename _Predicate>
JavaStyleStream& stable_partition(_Predicate predicate) {
std::stable_partition(_container.begin(), _container.end(), predicate);
return *this;
}
//C++11提供
template<typename _Predicate>
JavaStyleStream& partition_point(_Predicate predicate) {
std::partition_point(_container.begin(), _container.end(), predicate);
return *this;
}
//过滤&复制&合并&转换
template<typename _Predicate>
JavaStyleStream filter(_Predicate predicate) {
Cont<Tp, Alloc> newCont;
for(iterator iter = _container.begin(); iter != _container.end(); ++iter) {
if (predicate(*iter)) {
newCont.push_back(*iter);
}
}
JavaStyleStream<Cont, Tp> newSteram(newCont);
return std::move(newSteram);
}
template<typename _UnaryFunction>
JavaStyleStream<Cont, typename function_traits<_UnaryFunction>::return_type> transform(_UnaryFunction function) {
Cont<typename function_traits<_UnaryFunction>::return_type, std::allocator<typename function_traits<_UnaryFunction>::return_type>> newCont;
std::transform(_container.begin(), _container.end(), std::back_inserter(newCont), function);
JavaStyleStream<Cont, typename function_traits<_UnaryFunction>::return_type, std::allocator<typename function_traits<_UnaryFunction>::return_type>> newStream(newCont);
return std::move(newStream);
}
//复制
JavaStyleStream copy() {
Cont<Tp, Alloc> newCont;
std::copy(_container.begin(), _container.end(), std::back_inserter(newCont));
JavaStyleStream<Cont, Tp> newStream(newCont);
return newStream;
}
template<typename _Predicate>
JavaStyleStream copy_if(_Predicate predicate) {
Cont<Tp, Alloc> newCont;
std::copy_if(_container.begin(), _container.end(), std::back_inserter(newCont), predicate);
JavaStyleStream<Cont, Tp> newStream(newCont);
return newStream;
}
template<typename _Integer>
JavaStyleStream copy_n(_Integer integer) {
Cont<Tp, Alloc> newCont;
std::copy_n(_container.begin(), integer, std::back_inserter(newCont));
JavaStyleStream<Cont, Tp> newStream(newCont);
return newStream;
}
JavaStyleStream copy_backward() {
Cont<Tp, Alloc> newCont;
std::copy_backward(_container.begin(), _container.end(), std::back_inserter(newCont));
JavaStyleStream<Cont, Tp> newStream(newCont);
return newStream;
}
//遍历
template<typename _Function>
JavaStyleStream& for_each(_Function function) {
std::for_each(_container.begin(), _container.end(), function);
return *this;
}
//reduce
//集合
public:
JavaStyleStream(Cont<Tp, Alloc>& container)
: _container(container)
{};
JavaStyleStream(JavaStyleStream& stream)
: _container(stream._container)
{};
JavaStyleStream(JavaStyleStream&& stream)
: _container(stream._container)
{};
private:
Cont<Tp, Alloc> _container;
};
#endif //CPPTEST_JAVASTYLESTREAM_H