C++ 学习系列 -- 标准库常用得 algorithm function

这篇具有很好参考价值的文章主要介绍了C++ 学习系列 -- 标准库常用得 algorithm function。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

一   前言

c++ 标准库中提供了许多操作数据结构:vector、list、deque、map、set 等函数,学习并了解这些常用函数对于我们理解 c++ 的一些设计模式有着重要的作用。

二  常用的 algorithm function 源码

源代码位置:

bits/stl_algo.h

1.  accumulate

/**
   *  @brief  Accumulate values in a range.
   *
   *  Accumulates the values in the range [first,last) using operator+().  The
   *  initial value is @a init.  The values are processed in order.
   *
   *  @param  __first  Start of range.
   *  @param  __last  End of range.
   *  @param  __init  Starting value to add other values to.
   *  @return  The final sum.
   */
template<typename _InputIterator, typename _Tp>
    inline _Tp
    accumulate(_InputIterator __first, _InputIterator __last, _Tp __init)
    {

      for (; __first != __last; ++__first)
	__init = __init + *__first;
      return __init;
    }
 /**
   *  @brief  Accumulate values in a range with operation.
   *
   *  Accumulates the values in the range [first,last) using the function
   *  object @p __binary_op.  The initial value is @p __init.  The values are
   *  processed in order.
   *
   *  @param  __first  Start of range.
   *  @param  __last  End of range.
   *  @param  __init  Starting value to add other values to.
   *  @param  __binary_op  Function object to accumulate with.
   *  @return  The final sum.
   */
 
  template<typename _InputIterator, typename _Tp, typename _BinaryOperation>
    inline _Tp
    accumulate(_InputIterator __first, _InputIterator __last, _Tp __init,
	       _BinaryOperation __binary_op)
    {

      for (; __first != __last; ++__first)
	__init = __binary_op(__init, *__first);
      return __init;
    }

accumulate 函数又两个重载版本:

第一个函数的第三个参数是初始值,是单纯的将 数据累加到初始值 init 上;

第二个函数的第三个参数是 “累加”  的初始值,第四个参数是函数或者仿函数对象,是可以自定义 “累加” 的函数 binary_op ,该函数的作用是将迭代器中的每个元素都执行一遍 binar_op 后,将结果 “累加” 到 初始值 init 上

2. for_each

 /**
   *  @brief Apply a function to every element of a sequence.
   *  @ingroup non_mutating_algorithms
   *  @param  __first  An input iterator.
   *  @param  __last   An input iterator.
   *  @param  __f      A unary function object.
   *  @return   @p __f
   *
   *  Applies the function object @p __f to each element in the range
   *  @p [first,last).  @p __f must not modify the order of the sequence.
   *  If @p __f has a return value it is ignored.
  */
  template<typename _InputIterator, typename _Function>
    _Function
    for_each(_InputIterator __first, _InputIterator __last, _Function __f)
    {
      for (; __first != __last; ++__first)
	__f(*__first);
      return __f; // N.B. [alg.foreach] says std::move(f) but it's redundant.
    }

      for_each 函数第三个函数是函数或者仿函数对象,该函数作用是遍历迭代器,并对迭代器中的每个元素分别执行一次 _Function ,_Function 可以用户自定义

3. replace/replace_if

/**
   *  @brief Replace each occurrence of one value in a sequence with another
   *         value.
   *  @ingroup mutating_algorithms
   *  @param  __first      A forward iterator.
   *  @param  __last       A forward iterator.
   *  @param  __old_value  The value to be replaced.
   *  @param  __new_value  The replacement value.
   *  @return   replace() returns no value.
   *
   *  For each iterator @c i in the range @p [__first,__last) if @c *i ==
   *  @p __old_value then the assignment @c *i = @p __new_value is performed.
  */
  template<typename _ForwardIterator, typename _Tp>
    void
    replace(_ForwardIterator __first, _ForwardIterator __last,
	    const _Tp& __old_value, const _Tp& __new_value)
    {
      for (; __first != __last; ++__first)
	if (*__first == __old_value)
	  *__first = __new_value;
    }

  /**
   *  @brief Replace each value in a sequence for which a predicate returns
   *         true with another value.
   *  @ingroup mutating_algorithms
   *  @param  __first      A forward iterator.
   *  @param  __last       A forward iterator.
   *  @param  __pred       A predicate.
   *  @param  __new_value  The replacement value.
   *  @return   replace_if() returns no value.
   *
   *  For each iterator @c i in the range @p [__first,__last) if @p __pred(*i)
   *  is true then the assignment @c *i = @p __new_value is performed.
  */
  template<typename _ForwardIterator, typename _Predicate, typename _Tp>
    void
    replace_if(_ForwardIterator __first, _ForwardIterator __last,
	       _Predicate __pred, const _Tp& __new_value)
    {
      for (; __first != __last; ++__first)
	if (__pred(*__first))
	  *__first = __new_value;
    }

    3.1  replace 函数 第三个参数传入的是待被替换的旧值,第四个参数是 被替换后的新值,该函数执行后,会把迭代器中所有值等于旧值得元素都替换为新值

    3.2  replace_if 函数第三个参数是一个函数对象,第四个参数是替换后得新值。该函数得作用是将迭代器中所有符合传入函数规则得旧值替换为新值。

4. count/count_if

template<typename _InputIterator, typename _Predicate>
    typename iterator_traits<_InputIterator>::difference_type
    __count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred)
    {
      typename iterator_traits<_InputIterator>::difference_type __n = 0;
      for (; __first != __last; ++__first)
	if (__pred(__first))
	  ++__n;
      return __n;
    }

/**
   *  @brief Count the number of copies of a value in a sequence.
   *  @ingroup non_mutating_algorithms
   *  @param  __first  An input iterator.
   *  @param  __last   An input iterator.
   *  @param  __value  The value to be counted.
   *  @return   The number of iterators @c i in the range @p [__first,__last)
   *  for which @c *i == @p __value
  */
  template<typename _InputIterator, typename _Tp>
    inline typename iterator_traits<_InputIterator>::difference_type
    count(_InputIterator __first, _InputIterator __last, const _Tp& __value)
    {
      return std::__count_if(__first, __last,
			     __gnu_cxx::__ops::__iter_equals_val(__value));
    }

  /**
   *  @brief Count the elements of a sequence for which a predicate is true.
   *  @ingroup non_mutating_algorithms
   *  @param  __first  An input iterator.
   *  @param  __last   An input iterator.
   *  @param  __pred   A predicate.
   *  @return   The number of iterators @c i in the range @p [__first,__last)
   *  for which @p __pred(*i) is true.
  */
  template<typename _InputIterator, typename _Predicate>
    inline typename iterator_traits<_InputIterator>::difference_type
    count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred)
    {
      return std::__count_if(__first, __last,
			     __gnu_cxx::__ops::__pred_iter(__pred));
    }

   1. __count_if 函数第三个传入参数是一个函数或者仿函数对象,该函数的作用是遍历迭代器,统计有符合传入函数的元素个数

  2. count 函数第三个参数是一个值,该函数作用是遍历迭代器,统计与传入值相等的元素个数

  3. count_if 直接调用了 __count_if ,作用与 1 中描述相同

5. find/find_if

 /// This is an overload used by find algos for the Input Iterator case.
  template<typename _InputIterator, typename _Predicate>
    inline _InputIterator
    __find_if(_InputIterator __first, _InputIterator __last,
	      _Predicate __pred, input_iterator_tag)
    {
      while (__first != __last && !__pred(__first))
	++__first;
      return __first;
    }

  /// This is an overload used by find algos for the RAI case.
  template<typename _RandomAccessIterator, typename _Predicate>
    _RandomAccessIterator
    __find_if(_RandomAccessIterator __first, _RandomAccessIterator __last,
	      _Predicate __pred, random_access_iterator_tag)
    {
      typename iterator_traits<_RandomAccessIterator>::difference_type
	__trip_count = (__last - __first) >> 2;

      for (; __trip_count > 0; --__trip_count)
	{
	  if (__pred(__first))
	    return __first;
	  ++__first;

	  if (__pred(__first))
	    return __first;
	  ++__first;

	  if (__pred(__first))
	    return __first;
	  ++__first;

	  if (__pred(__first))
	    return __first;
	  ++__first;
	}

      switch (__last - __first)
	{
	case 3:
	  if (__pred(__first))
	    return __first;
	  ++__first;
	case 2:
	  if (__pred(__first))
	    return __first;
	  ++__first;
	case 1:
	  if (__pred(__first))
	    return __first;
	  ++__first;
	case 0:
	default:
	  return __last;
	}
    }

  template<typename _Iterator, typename _Predicate>
    inline _Iterator
    __find_if(_Iterator __first, _Iterator __last, _Predicate __pred)
    {
      return __find_if(__first, __last, __pred,
		       std::__iterator_category(__first));
    }

/**
   *  @brief Find the first occurrence of a value in a sequence.
   *  @ingroup non_mutating_algorithms
   *  @param  __first  An input iterator.
   *  @param  __last   An input iterator.
   *  @param  __val    The value to find.
   *  @return   The first iterator @c i in the range @p [__first,__last)
   *  such that @c *i == @p __val, or @p __last if no such iterator exists.
  */
  template<typename _InputIterator, typename _Tp>
    inline _InputIterator
    find(_InputIterator __first, _InputIterator __last,
	 const _Tp& __val)
    {
      return std::__find_if(__first, __last,
			    __gnu_cxx::__ops::__iter_equals_val(__val));
    }

  /**
   *  @brief Find the first element in a sequence for which a
   *         predicate is true.
   *  @ingroup non_mutating_algorithms
   *  @param  __first  An input iterator.
   *  @param  __last   An input iterator.
   *  @param  __pred   A predicate.
   *  @return   The first iterator @c i in the range @p [__first,__last)
   *  such that @p __pred(*i) is true, or @p __last if no such iterator exists.
  */
  template<typename _InputIterator, typename _Predicate>
    inline _InputIterator
    find_if(_InputIterator __first, _InputIterator __last,
	    _Predicate __pred)
    {
      return std::__find_if(__first, __last,
			    __gnu_cxx::__ops::__pred_iter(__pred));
    }

    1.  第一个 __find_if 函数的第三个参数是函数或者仿函数,第四个参数是 input_iterator_tag (该参数连对应的变量都没有,只有一个类型,其主要作用是为了在重载时与第二个 __find_if 进行区分,毕竟 顺序迭代查找与可以随机访问的查找效率上是不同的),该函数的作用是遍历迭代器,从中找出与传入值相等的元素,若是存在则返回该元素的迭代器,否则返回 _last

 2. 第二个 __find_if 函数的第三个参数是 函数或者仿函数,第四个参数是 random_access_iterator_tag (该参数连对应的变量都没有,只有一个类型,其主要作用是为了在重载时与第二个 __find_if 进行区分,毕竟 顺序迭代查找与可以随机访问的查找效率上是不同的),该函数的作用是历迭代器,从中找出与传入值相等的元素,若是存在则返回该元素的迭代器,否则返回 _last,效率上应该比第一个 __find_if 高一些。

3. 第三个 __find_if 函数的第三个参数是 函数或者仿函数,该函数的作用是个中转,其底层调用的是第一个或者第二个函数,只不过多了个询问迭代器类型的操作:std::__iterator_category

4. find 函数第三个参数 const _Tp&是传入一个待查找的值,该函数的作用是若是查找到与该值相等的元素,则返回对应的迭代器,否则返回 __last

5. find_if  函数的第三个参数是 函数或者仿函数,该函数底层调用的是第三个函数 __find_if ,该函数的作用是若是查到元素符合传入的函数规则则返回该元素的迭代器,否则返回 __last

6. sort

待补充

7. binary_search

template<typename _ForwardIterator, typename _Tp, typename _Compare>
    _ForwardIterator
    __lower_bound(_ForwardIterator __first, _ForwardIterator __last,
		  const _Tp& __val, _Compare __comp)
    {
      typedef typename iterator_traits<_ForwardIterator>::difference_type
	_DistanceType;

      _DistanceType __len = std::distance(__first, __last);

      while (__len > 0)
	{
	  _DistanceType __half = __len >> 1;
	  _ForwardIterator __middle = __first;
	  std::advance(__middle, __half);
	  if (__comp(__middle, __val))
	    {
	      __first = __middle;
	      ++__first;
	      __len = __len - __half - 1;
	    }
	  else
	    __len = __half;
	}
      return __first;
    }

  /**
   *  @brief Finds the first position in which @a val could be inserted
   *         without changing the ordering.
   *  @param  __first   An iterator.
   *  @param  __last    Another iterator.
   *  @param  __val     The search term.
   *  @return         An iterator pointing to the first element <em>not less
   *                  than</em> @a val, or end() if every element is less than 
   *                  @a val.
   *  @ingroup binary_search_algorithms
  */
  template<typename _ForwardIterator, typename _Tp>
    inline _ForwardIterator
    lower_bound(_ForwardIterator __first, _ForwardIterator __last,
		const _Tp& __val)
    {
      return std::__lower_bound(__first, __last, __val,
				__gnu_cxx::__ops::__iter_less_val());
    }
  /**
   *  @brief Determines whether an element exists in a range.
   *  @ingroup binary_search_algorithms
   *  @param  __first   An iterator.
   *  @param  __last    Another iterator.
   *  @param  __val     The search term.
   *  @return True if @p __val (or its equivalent) is in [@p
   *  __first,@p __last ].
   *
   *  Note that this does not actually return an iterator to @p __val.  For
   *  that, use std::find or a container's specialized find member functions.
  */
  template<typename _ForwardIterator, typename _Tp>
    bool
    binary_search(_ForwardIterator __first, _ForwardIterator __last,
		  const _Tp& __val)
    {
      _ForwardIterator __i
	= std::__lower_bound(__first, __last, __val,
			     __gnu_cxx::__ops::__iter_less_val());
      return __i != __last && !(__val < *__i);
    }

  /**
   *  @brief Determines whether an element exists in a range.
   *  @ingroup binary_search_algorithms
   *  @param  __first   An iterator.
   *  @param  __last    Another iterator.
   *  @param  __val     The search term.
   *  @param  __comp    A functor to use for comparisons.
   *  @return  True if @p __val (or its equivalent) is in @p [__first,__last].
   *
   *  Note that this does not actually return an iterator to @p __val.  For
   *  that, use std::find or a container's specialized find member functions.
   *
   *  The comparison function should have the same effects on ordering as
   *  the function used for the initial sort.
  */
  template<typename _ForwardIterator, typename _Tp, typename _Compare>
    bool
    binary_search(_ForwardIterator __first, _ForwardIterator __last,
		  const _Tp& __val, _Compare __comp)
    {
      _ForwardIterator __i
	= std::__lower_bound(__first, __last, __val,
			     __gnu_cxx::__ops::__iter_comp_val(__comp));
      return __i != __last && !bool(__comp(__val, *__i));
    }

1. 第一个 binary_search 函数的  三个参数 __val 是查找的目标值,该函数的作用是利用二分查找法查找目标值,若是查找到目标值,则返回 true,否则返回 false

2. 第二个 binar_search 函数的第三个参数 __val 是查找的目标值 ,第四个参数 __comp   是函数或者仿函数对象,该函数 是利用二分查找法查找目标值,若是查找到某个值使得 __comp(__val, target) 返回 true,则说明查到了目标值,此时返回 true,否则返回 法拉瑟文章来源地址https://www.toymoban.com/news/detail-716303.html

三   示例

#include<iostream>
#include<algorithm>

using namespace std;

struct PredicateReplace: public std::unary_function<int, bool>
{
    bool operator()(const int x) const
    {
        return x % 3 == 0;
    }
};

struct PredictCount: public std::unary_function<int, bool>
{
    bool operator()(int x)
    {
        return x % 3 == 1;
    }
};

struct PredictBinarySearch:public std::binary_function<int, int, bool>
{
    bool operator()(int x, int y)
    {
        std::cout << "x: " << x << ", y: " << y << std::endl;
        return x < y;
    }

};

int main()
{
    std::vector<int> vec = {10, 50, 60, 20, 30, 40};

    int init = 0;
    // 1. accumulate
    std::cout << "------ test accumulate ------" << std::endl;
    std::cout << std::accumulate(vec.begin(), vec.end(), init) << std::endl; // 210

    init = 600;
    std::cout << std::accumulate(vec.begin(), vec.end(), init, std::minus<int>()) << std::endl; // 390
    std::cout << "------ test accumulate ------" << std::endl;


    // 2. for_each
    struct printVal{

        void operator()(int x){
            std::cout << x << " ";
        }
    };
    std::cout << "------ test for_each ------" << std::endl;

    std::for_each(vec.begin(), vec.end(),printVal());
    cout << endl;
    std::cout << "------ test for_each ------" << std::endl;


    // 3. replace  replace_if

    std::cout << "------ test replace ------" << std::endl;

    std::replace(vec.begin(), vec.end(), 50, 90);
    std::for_each(vec.begin(), vec.end(),printVal());
    cout << endl;

    std::vector<int> vec_replace1 = vec;
    std::replace_if(vec_replace1.begin(), vec_replace1.end(), PredicateReplace(), 666);
    std::for_each(vec_replace1.begin(), vec_replace1.end(),printVal());
    cout << endl;

    PredicateReplace pp;
    std::vector<int> vec_replace2 = vec;
    std::replace_if(vec_replace2.begin(), vec_replace2.end(), std::not1(pp), 666);
    std::for_each(vec_replace2.begin(), vec_replace2.end(),printVal());
    cout << endl;

    std::cout << "------ test replace ------" << std::endl;

    // 4. count  count_if
    std::cout << "------ test count ------" << std::endl;
    std::vector<int> vec_cout1 = vec;
    std::cout << std::count(vec_cout1.begin(), vec_cout1.end(), 60) << std::endl;
    std::cout << std::count_if(vec_cout1.begin(), vec_cout1.end(), PredictCount()) << std::endl;
    std::cout << "------ test count ------" << std::endl;

    // 5. find  find_if
    std::cout << "------ test find ------" << std::endl;
    auto iter = std::find(vec.begin(), vec.end(), 30);
    if(iter != vec.end())
        std::cout << *iter << std::endl;
    iter = std::find_if(vec.begin(), vec.end(), PredictCount());
    if(iter != vec.end())
        std::cout << *iter << std::endl;
    std::cout << "------ test find ------" << std::endl;


    // 6. sort
    std::cout << "------ test sort ------" << std::endl;
    std::sort(vec.begin(), vec.end(), std::greater<int>());
    std::for_each(vec.begin(), vec.end(),printVal()); // 60 50 40 30 20 10
    cout << endl;

    std::sort(vec.begin(), vec.end(), std::less<int>()); // 10 20 30 40 50 60
    std::for_each(vec.begin(), vec.end(),printVal());
    cout << endl;

    std::cout << "------ test sort ------" << std::endl;


    // 7. binary_search
    std::cout << "------ test binary_search ------" << std::endl;

    bool isExists = std::binary_search(vec.begin(), vec.end(), 50);

    if(isExists)
    {
        std::cout << "50 is existed. " << std::endl;
    }
    else
    {
        std::cout << "50 is not existed. " << std::endl;
    }

    bool isExists2 = std::binary_search(vec.begin(), vec.end(), 60, PredictBinarySearch());
    if(isExists2)
    {
        std::cout << "x == 60 is existed. " << std::endl;
    }
    else
    {
        std::cout << "x == 60 is not existed. " << std::endl;
    }
    std::cout << "------ test binary_search ------" << std::endl;

    return 0;
}

到了这里,关于C++ 学习系列 -- 标准库常用得 algorithm function的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • C++学习笔记之四(标准库、标准模板库、vector类)

    C + + C++ C + + 标准库指的是标准程序库( S t a n d a r d Standard St an d a r d L i b a r a y Libaray L iba r a y ),它定义了十个大类,其中包括我们比较熟悉的 i o s t r e a m , s t r i n g iostream, string i os t re am , s t r in g 都是这十个大类的其中一个类中的一个小类。而 c + + c++ c + + 的标准模板库也

    2024年02月07日
    浏览(28)
  • 现代C++学习指南-标准库

    在[上一章](https://www.yuque.com/docs/share/adb5b1e4-f3c6-46fd-ba4b-4dabce9b4f2a?# 《现代C++学习指南-类型系统》)我们探讨了C++的类型系统,并提出了从低到高,又从高到低的学习思路,本文就是一篇从高到低的学习指南,希望能提供一种新的视角。 编程语言一般分为两个部分,一部分是语

    2024年02月09日
    浏览(23)
  • 【STM32】标准库与HAL库对照学习系列教程大全

    前言:开始工作后,学习的时间变少了很多,但是今年的1024节,还是打算送个福利给大家,将之前的STM32教程汇总,方便大家学习与查找,学习嵌入式已经快3年了吧,感觉自己还是在入门阶段,STM32也快一年没碰了,现在经常用的大多都还是工作上的内容,所以文章有不对的

    2024年02月08日
    浏览(32)
  • C++学习笔记-第11单元 标准模板库介绍

    注:本部分内容主要来自中国大学MOOC北京邮电大学崔毅东的 《C++程序设计》课程。 注:94条 C++程序规范。   本单元重点是对标准模板库中的 顺序容器 、 关联容器 的使用,以及 如何创建迭代器以遍历容器 。在使用容器时要注意不同容器的实现方式对遍历、搜索、删除、

    2024年02月13日
    浏览(28)
  • C++系列二:STL教程-常用算法

    提示:写完文章后,目录可以自动生成,如何生成可参考右边的帮助文档 还有一些我在尝试中迷惑不解的,有点玄幻。 排序算法: 合并算法: 查找算法: 筛选分组算法: 其他:

    2024年02月13日
    浏览(34)
  • c++系列之string类的常用接口函数

    💗 💗 博客:小怡同学 💗 💗 个人简介:编程小萌新 💗 💗 如果博客对大家有用的话,请点赞关注再收藏 🌞 string时表示字符串的字符类 //使用 string类包含#include 头文件 以及 using namespace std string容量相关接口 (size(),capacity(),clear(),empty) 1.size()是元素个数 //. size()与length()方

    2024年02月10日
    浏览(28)
  • C++学习笔记——C++ 新标准(C++11、C++14、C++17)引入的重要特性

    目录 1、简介 2.自动类型推导和初始化 示例代码 3.智能指针 示例代码 4.Lambda 表达式 示例代码 5.右值引用和移动语义 示例代码 6.并发编程支持 示例代码 7.其他特性 八、案例:实现一个简单的并发下载器 上一篇文章:     C++标准模板库(STL)是C++的一个重要组成部分,它提

    2024年01月19日
    浏览(28)
  • C++进阶语法——STL 标准模板库(下)(Standard Template Library)【学习笔记(七)】

    1、迭代器 迭代器可以将任意的容器抽象成一个序列,可以使用迭代器遍历容器中的元素 迭代器设计的目的是为了解决容器与算法之间的耦合问题,与指针类似,可以通过迭代器访问容器中的元素 迭代器的声明方式为: 容器类型::iterator 变量名称 , 可以理解为一个普通的指

    2024年02月06日
    浏览(39)
  • Data Structure, Algorithm,and Applications in C++

    在学习这本书进阶内容之前,我们可以跟着它的第一章部分再巩固和复习。本书由Sartaj Sahni撰写,由王立柱和刘志红翻译。全书通俗易懂,内容丰富,是巩固C++内容的不二选择。希望本文对各位有所帮助。 目录 1.函数与参数 1.1.传值参数 1.2.模板函数 1.3.引用参数 1.4.常量引用

    2024年02月16日
    浏览(32)
  • 深度学习基础入门篇[七]:常用归一化算法、层次归一化算法、归一化和标准化区别于联系、应用案例场景分析。

    【深度学习入门到进阶】必看系列,含激活函数、优化策略、损失函数、模型调优、归一化算法、卷积模型、序列模型、预训练模型、对抗神经网络等 专栏详细介绍:【深度学习入门到进阶】必看系列,含激活函数、优化策略、损失函数、模型调优、归一化算法、卷积模型、

    2024年02月13日
    浏览(29)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包