C++numeric头文件功能详解

x33g5p2x  于11个月前 转载在 C/C++  
字(7.3k)|赞(0)|评价(0)|浏览(59)

本文代码摘自 cplusplus.com

一,accumulate

1,调用形式:

(1)默认形式调用

template <class InputIterator, class T>
   T accumulate (InputIterator first, InputIterator last, T init);

(2)以指定计算方式 binary_op 调用

template <class InputIterator, class T, class BinaryOperation>
   T accumulate (InputIterator first, InputIterator last, T init,BinaryOperation binary_op);

各个参数意义:
first : 参与运算的数值序列的首部
last : 参与运算的数值序列的尾部
init : 参与运算的初始值
binary_op : 计算方式

2,定义及实现:

template <class InputIterator, class T>
   T accumulate (InputIterator first, InputIterator last, T init)
{
  while (first!=last) {
    init = init + *first;  // or: init=binary_op(init,*first) for the binary_op version
    ++first;
  }
  return init;
}

3,功能解释及应用:

该函数的默认功能是返回 init 与数值序列中各个元素相加后的和。

#include <iostream> 
#include <functional> 
#include <numeric> 
using namespace std;

int myfunction (int x, int y) {return x+2*y;}  //自定义的计算方式
struct myclass { 
	int operator()(int x, int y) {return x+3*y;} //重载运算符
} myobject;

int main () {
  int init = 100;
  int numbers[] = {10,20,30};

  cout << "使用默认方式计算: ";
  cout << accumulate(numbers,numbers+3,init) << endl << endl;

  cout << "使用minus函数计算: ";
  cout << accumulate (numbers, numbers+3, init, std::minus<int>()) << endl << endl;
  
/*minus函数定义如下 template <class T> struct minus : binary_function <T,T,T> { T operator() (const T& x, const T& y) const {return x-y;} }; */

  cout << "使用自定义的myfunction函数计算: ";
  cout << accumulate (numbers, numbers+3, init, myfunction) << endl << endl;

  std::cout << "使用重载运算符计算: ";
  std::cout << std::accumulate (numbers, numbers+3, init, myobject) << endl << endl;

  return 0;
}

二,adjacent_difference

1,调用形式:

(1)默认形式调用

template <class InputIterator, class OutputIterator>
   OutputIterator adjacent_difference (InputIterator first, InputIterator last,OutputIterator result);

(2)指定计算方式调用

template <class InputIterator, class OutputIterator, class BinaryOperation>
   OutputIterator adjacent_difference ( InputIterator first, InputIterator last, OutputIterator result, BinaryOperation binary_op );

各个参数意义:
first : 参与运算的数值序列的首部
last : 参与运算的数值序列的尾部
result : 存储运算结果的数值序列
binary_op : 计算方式

2,定义及实现:

template <class InputIterator, class OutputIterator>
   OutputIterator adjacent_difference (InputIterator first, InputIterator last,OutputIterator result)
{
  if (first!=last) {
    typename iterator_traits<InputIterator>::value_type val,prev;
    *result = prev = *first;
    while (++first!=last) {
      val = *first;
      *++result = val - prev;  // or: *++result = binary_op(val,prev)
      prev = val;
    }
    ++result;
  }
  return result;
}

3,功能解释及应用:

该函数的默认功能是将数值序列的相邻元素相减,结果存储到另一个序列中。

#include <iostream> 
#include <functional> 
#include <numeric> 
using namespace std;

int myop (int x, int y) {return x+y;} //自定义函数 

int main () {
  int val[] = {1,2,3,5,9,11,12};
  int result[7];

  adjacent_difference (val, val+7, result);
  cout << "使用默认方式计算: ";
  for (int i=0; i<7; i++) cout << result[i] << ' ';
  cout << endl << endl;

  adjacent_difference (val, val+7, result, multiplies<int>());
  cout << "使用multiplies函数计算: ";
  for (int i=0; i<7; i++) cout << result[i] << ' ';
  cout << endl << endl;
/* multiplies函数定义 template <class T> struct multiplies : binary_function <T,T,T> { T operator() (const T& x, const T& y) const {return x*y;} }; */
 
  adjacent_difference (val, val+7, result, myop);
  cout << "使用自定义函数计算: ";
  for (int i=0; i<7; i++) cout << result[i] << ' ';
  cout << endl << endl;
  
  return 0;
}

三,inner_product

1,调用方式:

(1)默认方式调用

template <class InputIterator1, class InputIterator2, class T>
   T inner_product (InputIterator1 first1, InputIterator1 last1,InputIterator2 first2, T init);

(2)指定计算方式调用

template <class InputIterator1, class InputIterator2, class T,class BinaryOperation1, class BinaryOperation2>
   T inner_product (InputIterator1 first1, InputIterator1 last1,
                    InputIterator2 first2, T init,
                    BinaryOperation1 binary_op1,
                    BinaryOperation2 binary_op2);

各个参数意义:
first1 : 参与运算的第一个数值序列的首部
last1 : 参与运算第一个的数值序列的尾部
first2 : 参与运算第二个的数值序列的首部
last2 : 参与运算的第二个数值序列的尾部
init : 初始值
binary_op1 : 两个序列中对应元素的计算方式
binary_op2 : 对执行binary-op1得到的若干结果的计算方式

2,定义及实现:

template <class InputIterator1, class InputIterator2, class T>
   T inner_product (InputIterator1 first1, InputIterator1 last1,
                    InputIterator2 first2, T init)
{
  while (first1!=last1) {
    init = init + (*first1)*(*first2);
               // or: init = binary_op1 (init, binary_op2(*first1,*first2));
    ++first1; ++first2;
  }
  return init;
}

3,功能解释及应用:

该函数默认功能是将两个序列对应位置上的元素相乘,将结果与初始值相加。

#include <iostream> 
#include <functional> 
#include <numeric> 
using namespace std;

int myaccumulator (int x, int y) {return x-y;} //自定义函数 
int myproduct (int x, int y) {return x+y;}  //自定义函数 

int main () {
  int init = 100;
  int series1[] = {10,20,30};
  int series2[] = {1,2,3};

  cout << "使用默认方式计算: ";
  cout << std::inner_product(series1,series1+3,series2,init) << endl << endl;

  cout << "使用minus和divides函数计算: ";
  cout << std::inner_product(series1,series1+3,series2,init,
                                  minus<int>(), divides<int>()) << endl << endl;
/*minus函数定义如下 template <class T> struct minus : binary_function <T,T,T> { T operator() (const T& x, const T& y) const {return x-y;} }; */

/* divides函数定义如下 template <class T> struct divides : binary_function <T,T,T> { T operator() (const T& x, const T& y) const {return x/y;} }; */
  
  cout << "使用自定义函数计算: ";
  cout << inner_product(series1,series1+3,series2,init,
                                  myaccumulator,myproduct) << endl << endl;

  return 0;
}

四,partial_sum

1,调用方式:
(1)默认方式调用

template <class InputIterator, class OutputIterator>
   OutputIterator partial_sum (InputIterator first, InputIterator last,
                               OutputIterator result);

(2)指定计算方式调用

template <class InputIterator, class OutputIterator, class BinaryOperation>
   OutputIterator partial_sum (InputIterator first, InputIterator last,
                               OutputIterator result, BinaryOperation binary_op);

各个参数意义:
first : 参与运算的数值序列的首部
last : 参与运算的数值序列的尾部
result : 存储运算结果的数值序列
binary_op : 计算方式

2,定义及实现:

template <class InputIterator, class OutputIterator>
   OutputIterator partial_sum (InputIterator first, InputIterator last,
                               OutputIterator result)
{
  if (first!=last) {
    typename iterator_traits<InputIterator>::value_type val = *first;
    *result = val;
    while (++first!=last) {
      val = val + *first;   // or: val = binary_op(val,*first)
      *++result = val;
    }
    ++result;
  }
  return result;
}

3,功能解释及应用:

该函数默认功能是将数值序列的前 i 个元素的和保存在 result[i] 中。

#include <iostream> 
#include <functional> 
#include <numeric> 
using namespace std;

int myop (int x, int y) {return x+y+1;} //自定义函数 

int main () {
  int val[] = {1,2,3,4,5};
  int result[5];

  partial_sum (val, val+5, result);
  cout << "使用默认方式计算: ";
  for (int i=0; i<5; i++) cout << result[i] << ' ';
  cout << endl << endl;

  partial_sum (val, val+5, result, std::multiplies<int>());
  cout << "使用multiplies函数计算: ";
  for (int i=0; i<5; i++) std::cout << result[i] << ' ';
  cout << endl << endl;
  
  partial_sum (val, val+5, result, myop);
  cout << "使用自定义函数计算: ";
  for (int i=0; i<5; i++) std::cout << result[i] << ' ';
  cout << endl << endl;
  
  return 0;
}

五,iota

1,调用方式:

template <class ForwardIterator, class T>
  void iota (ForwardIterator first, ForwardIterator last, T val);

各个参数说明:
first : 参与运算的数值序列的首部
last : 参与运算的数值序列的尾部
val : 初始值

2,定义及实现:

template <class ForwardIterator, class T>
  void iota (ForwardIterator first, ForwardIterator last, T val)
{
  while (first!=last) {
    *first = val;
    ++first;
    ++val;
  }
}

3,功能解释及应用

该函数默认功能是以 val 初始值对序列的 first 到 last 位置赋值,每个位置的值比前一个位置的值大1。

#include <iostream> 
#include <numeric> 
using namespace std;

int main () {
  int numbers[10];

  iota(numbers,numbers+10,100);

  cout << "numbers:";
  for (int& i:numbers) cout << ' ' << i;
  cout << endl << endl;

  return 0;
}

相关文章