首页 > 编程语言 >Java Style的C++容器流式处理类

Java Style的C++容器流式处理类

时间:2022-10-11 11:00:50浏览次数:63  
标签:std Style container begin C++ return Java value end

很久没有上博客园了,最近一段时间,因为工作的关系时间上比较闲,利用闲暇时间重新翻了一下丢弃很久的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

标签:std,Style,container,begin,C++,return,Java,value,end
From: https://www.cnblogs.com/richardy2012/p/16778505.html

相关文章

  • IDEA jsp 写Java脚本的时候不能使用out.print()问题
    IDEAjsp写Java脚本的时候不能使用out.print()问题参考:ideajsp无法使用out.print方法_NoBug的博客-CSDN博客_ideajspout问题:  解决:File->ProjectStructure......
  • C++之可变模板参数打印及Pari的逐块式构造(Piecewise Construction)
    classFoo{public:Foo(tuple<int,double>){cout<<"Foo(tuple<int,double>)"<<endl;}template<typenameT>voidprint(Tt)......
  • Java 多线程(五)线程状态
    一,线程五大状态:详细说明:   二,线程方法:   1.停止线程*不推荐使用JDK提供的stop(),destroy()方法【已废弃】*推荐线程自己停下来*建议使用一个标志位进......
  • JavaScript实现深拷贝和浅拷贝
    js的数据类型分为两种一种是基本数据类型:字符串(String)、数字(Number)、布尔(Boolean)、对空(Null)、未定义(Undefined)一种是引用数据类型:对象(Object)、数组(Array)、函数(......
  • 力扣594(java&python)-最长和谐子序列(简单)
    题目:和谐数组是指一个数组里元素的最大值和最小值之间的差别正好是1。现在,给你一个整数数组nums,请你在所有可能的子序列中找到最长的和谐子序列的长度。数组的子序......
  • Java学习之路:运算符
    2022-10-1010:34:08......
  • Java反序列化之C3P0链学习
    0x01前言 再多打一点基础吧,后续打算先看一看 XStream,Weblogic,strusts2 这些个0x02C3P0 组件介绍C3P0 是一个开源的 JDBC 连接池,它实现了数据源和 JNDI 绑定,......
  • JavaWeb学习(一)SQL
    一、简介1、以分号结尾2、不区分大小写3、注释: --空格    #    /**/二、DDL:操作数据库、表等1、查询:showdatabases 2、创建:createdatab......
  • 密码强度的正则表达式(JavaScript)总结
    密码强度的正则表达式(JavaScript)总结简言本文给出了两个密码强度的正则表达式方案,一个简单,一个更复杂和安全。并分别给出了两个方案的解析和测试程序。一般大家可以根据......
  • Java全局唯一ID生成策略
    在分布式系统中常会需要生成系统唯一ID,生成ID有很多方法,根据不同的生成策略,以满足不同的场景、需求以及性能要求。1、数据库自增序列这是最常见的一种方式,利用DB来生成全......