C++ STL中的数字标头|集合2(adjacent_difference()，inner_product()和iota())

在C++ STL中，numeric标头为数字算法提供了一组丰富而有用的函数，包括accumulate()、count_if()、transform()等等。另外，该标头还提供了用于数字序列操作的三个重要函数，分别是：

• adjacent_difference()
• inner_product()
• iota()

在本篇文章中，我们将对这三个函数进行介绍并提供使用示例。

adjacent_difference()

adjacent_difference()是一个很有用的函数，它可以计算前一个元素和当前元素之间的差异，并将结果存储在另一个序列（通常为输出序列）中。该函数的声明如下：

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

该函数接受三个参数：

• first：要计算的序列的开始位置。
• last：要计算的序列的结束位置。
• result：存储结果的序列的开始位置。

以下是一个使用示例：

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

int main()
{
    vector<int> nums = { 1, 2, 3, 4, 5 };
    vector<int> diffs(nums.size());

    adjacent_difference(nums.begin(), nums.end(), diffs.begin());

    for (int n : diffs) {
        cout << n << " ";
    }
    cout << endl;

    return 0;
}

输出结果为：

1 1 1 1 1

在上面的示例中，nums是要进行差分处理的输入序列，diffs是用于存储结果的输出序列。adjacent_difference()函数将对nums序列进行差分处理，并将结果存储在diffs序列中，即：

• diffs[0] = nums[0] = 1
• diffs[1] = nums[1] - nums[0] = 2 - 1 = 1
• diffs[2] = nums[2] - nums[1] = 3 - 2 = 1
• diffs[3] = nums[3] - nums[2] = 4 - 3 = 1
• diffs[4] = nums[4] - nums[3] = 5 - 4 = 1

因此，输出结果为1 1 1 1 1。

inner_product()

inner_product()函数用于计算两个序列的内积（即点积），该函数的声明如下：

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

该函数接受四个参数：

• first1：要计算的第一个序列的开始位置。
• last1：要计算的第一个序列的结束位置。
• first2：要计算的第二个序列的开始位置。
• init：初始内积值。

以下是一个使用示例：

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

int main()
{
    vector<int> nums1 = { 1, 2, 3, 4, 5 };
    vector<int> nums2 = { 6, 7, 8, 9, 10 };

    int inner_prod = inner_product(nums1.begin(), nums1.end(), nums2.begin(), 0);

    cout << "inner product = " << inner_prod << endl;

    return 0;
}

输出结果为：

inner product = 130

在上面的示例中，nums1和nums2是要进行内积计算的两个序列。inner_product()函数将对这两个序列进行内积计算，并将结果返回，即：

• inner_prod = nums1[0]*nums2[0] + nums1[1]*nums2[1] + nums1[2]*nums2[2] + nums1[3]*nums2[3] + nums1[4]*nums2[4]
• inner_prod = 1*6 + 2*7 + 3*8 + 4*9 + 5*10
• inner_prod = 6 + 14 + 24 + 36 + 50
• inner_prod = 130

因此，输出结果为inner product = 130。

iota()

iota()函数可以用于生成一系列连续递增的数值序列，该函数的声明如下：

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

该函数接受三个参数：

• first：要填充的序列的开始位置。
• last：要填充的序列的结束位置。
• value：序列起始值。

以下是一个使用示例：

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

int main()
{
    vector<int> nums(10);

    iota(nums.begin(), nums.end(), 1);

    for (int n : nums) {
        cout << n << " ";
    }
    cout << endl;

    return 0;
}

输出结果为：

1 2 3 4 5 6 7 8 9 10

在上面的示例中，nums是要填充的数值序列，iota()函数将生成一系列连续递增的数值并填充到nums中，即：

• nums[0] = 1
• nums[1] = nums[0] + 1 = 2
• nums[2] = nums[1] + 1 = 3
• ···
• nums[8] = nums[7] + 1 = 9
• nums[9] = nums[8] + 1 = 10

因此，输出结果为1 2 3 4 5 6 7 8 9 10。