程序员经验分享-hwhale

[C++]＜numeric＞头文件介绍

2023-05-16

一、摘要

C++的<numeric>头文件中包含了一系列可用于操作数值序列（sequences of numeric value）的函数，通过修改函数的参数类型也可以将这些函数应用到非数值序列中。熟练使用<numeric>中的函数可以方便地对例如vector<>,list<>等容器进行数值计算。
在C++11标准下，<numeric>中主要包括accumulate(),adjacent_difference(),inner_product(),partial_sum()和iota()这五个函数，C++17又增加了gcd(),lcm()和midpoint()等函数。
本文将基于C++11标准主要讲解前五个函数的用法以及注意事项，囿于篇幅限制C++17标准中新增的函数本文不做过多介绍，更详尽的介绍读者可以参考Standard library header < numeric >。

本文第二部分是对accumulate(),adjacent_difference(),inner_product(),partial_sum()和iota()五个函数的介绍和使用注意事项。第三部分简要提及了C++17中新增的几个常用的函数，本文第四部分列出了本文参考的文章链接。

二、C++11标准<numeric>头文件内函数简介

1. accumulate()函数介绍

accumulate()函数返回数组内元素的累积值。
例如，可以使用accumulate()函数计算vector<int> nums中所有元素的累加和，通过修改操作符(binary_op)可以计算累乘积或其他自定义累计结果。

(1).函数定义

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

first, last: 容器迭代器，计算范围；

init: 初始值，默认为1。若初始值init=2，那么accumulate(nums.begin(),nums.end(),2) 返回 2+nums[0]+nums[1]+…+nums[n-1]；

binary_op: 元素间的操作符号，默认为plus<T>(求和)。

(2).用法示例

a. 基本用法，求vector<int> nums的元素累计和、累计减、累计乘、累计除

代码：

#include <iostream>
#include <vector>
#include <numeric>
using namespace std;
int main(int, char**) {
    vector<int> nums = { 6,3,2 };
    // 默认求和，输出为：0+6+3+2 = 11
    cout << accumulate(nums.begin(), nums.end(), 0) << endl;
    // 初始值为1求和，输出为：1+6+3+2 = 12
    cout << accumulate(nums.begin(), nums.end(), 1) << endl;
    // 求累减，输出为：0-6-3-2 = -11
    cout << accumulate(nums.begin(), nums.end(), 0, minus<int>()) << endl;
    // 求累乘，输出为：1*6*3*2 = 36
    cout << accumulate(nums.begin(), nums.end(), 1, multiplies<int>()) << endl;
    // 求累除，输出为：36/6/3/2 = 1
    cout << accumulate(nums.begin(), nums.end(), 36, divides<int>()) << endl;
    return 0;
}

输出：

11
12
-11
36
1

b. 自定义操作符binary_op

如1.所示，可以设置二元操作符为plus,minus,multiplies和divides对容器内的元素进行加、减、乘和除的accumulate操作。

同样的，我们可以使用函数指针、函数对象或lambda表达式自定义一个二元运算符对元素进行accumulate操作。

接下来我们定义一个 求和后再模3 的二运运算符 add_mod_3_fun，即add_mod_3_fun(a,b) = (a+b)%3，然后使用该二元运算符对nums进行accumulate操作。

代码如下：

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

int add_mod_3_fun(const int& a, const int& b) {
    return (a + b) % 3;
}
class ADD_MOD_3 {
public:
    int operator()(const int& a, const int& b) {
        return (a + b) % 3;
    }
};

int main(int, char**) {
    vector<int> nums = { 6,3,2 };
    // 使用自定义二元运算符
    
    // 使用函数指针，输出为 (0+6)%3=0 -> (0+3)%3=0 -> (0+2)%3 = 2
    cout << accumulate(nums.begin(), nums.end(), 0, add_mod_3_fun) << endl;
    // 使用函数对象
    cout << accumulate(nums.begin(), nums.end(), 0, ADD_MOD_3()) << endl;
    // 使用lambda表达式
    cout << accumulate(nums.begin(), nums.end(), 0, [](const int& a, const int& b) {return (a + b) % 3;}) << endl;
    return 0;
}

输出：

2
2
2

需要注意的是，在使用函数指针、函数对象或lambda表达式自定义运算符号时，参数列表应该为const int&类型以保证acumulate()函数不会对数组内原有元素做任何修改，尽管不为const int&类型依旧可以正常运行，但是为了安全考虑还是需要尽量使用const int&。

2.adjacent_difference()函数介绍

从名字也可以看出adjacent_difference()是用来计算数组各元素与相邻元素(这里的相邻指的是前一个元素)之间差异的函数。
例如：若nums为待计算数组，result为存放差异结果的数组，那么：

result[0] = nums[0]
result[1] = nums[1] - nums[0]
result[2] = nums[2] - nums[1]
result[3] = nums[3] - nums[2]
result[4] = nums[4] - nums[3]
...

可以看到，由于数组首个元素没有前一个元素，函数规定数组首个元素与前一个元素的差异为首个元素本身。另外在计算差异时，默认使用-减法运算，即differenc[i]=nums[i]-nums[i-1]。

(1).函数定义

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

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).用法示例

a. 基本用法，求vector<int>的各元素与前一个元素的差、和、积和商

代码：

#include <iostream>
#include <vector>
#include <numeric>
using namespace std;
int main(int, char**) {
    vector<int> nums = { 1,2,3,5,9,11,12 };
    cout << "nums:";
    for (int i = 0; i < nums.size(); i++) {
        cout << nums[i] << " ";
    }
    cout << endl;
    vector<int> results(nums.size());
    // 计算各元素与前一个元素的 差
    cout << "minus:";
    vector<int>::iterator iter = adjacent_difference(nums.begin(), nums.end(), results.begin());
    for (int i = 0; i < results.size();i++) {
        cout << results[i] << " ";
    }
    cout << endl;
    // 计算各元素与前一个元素的 和
    cout << "plus:";
    iter = adjacent_difference(nums.begin(), nums.end(), results.begin(), plus<int>());
    for (int i = 0; i < results.size();i++) {
        cout << results[i] << " ";
    }
    cout << endl;
    // 计算各元素与前一个元素的 乘
    cout << "multiplies:";
    iter = adjacent_difference(nums.begin(), nums.end(), results.begin(), multiplies<int>());
    for (int i = 0; i < results.size();i++) {
        cout << results[i] << " ";
    }
    cout << endl;
    // 计算各元素与前一个元素的 除
    cout << "divides:";
    iter = adjacent_difference(nums.begin(), nums.end(), results.begin(), divides<int>());
    for (int i = 0; i < results.size();i++) {
        cout << results[i] << " ";
    }
    cout << endl;
    return 0;
}

结果：

nums:1 2 3 5 9 11 12
minus:1 1 1 2 4 2 1
plus:1 3 5 8 14 20 23
multiplies:1 2 6 15 45 99 132
divides:1 2 1 1 1 1 1

从输出结果中我们可以看出，无论我们使用什么运算符（减、加、乘还是除）计算差异，数组首个元素与前一个元素的差异都为首个元素本身。

b. 自定义操作符binary_op

与accumulate()类似，adjacent_difference()函数中也可以使用函数指针、函数对象或lambda表达式自定义差异运算法则，此处不在赘述。

c. 注意事项

  • 在使用数组result存储nums差异结果时，需要保证result.size()>=nums.size()；
  • adjacent_difference()函数的返回值指向的是 最后一个差异结果的下一个元素位置，而不是result数组的最后一个位置。
    例如，若nums.size()等于3，result.size()等于5，那么
    iter=adjacent_difference(nums.begin(), nums.end(), result.begin());
    之后，iter指向result的第4个元素位置。

3.inner_product()函数介绍

inner product直译成中文为内积，的确该函数的功能与向量计算中的内积运算类似，inner_product()函数可以计算两个数组（向量）的内积结果。

例如：
两个数组分别为nums_1 = {1,2,3}，nums_2 = {2,3,4}。那么两数组的内积

inner_product(nums_1.begin(), nums_1.end(), nums_2.begin(),0);

即为:0 + (1*2)+(2*3)+(3*4) = 20。

(1).函数定义

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

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：容器迭代器，分别代表第一个数组的起始位置、终止位置和第二个数组的起始位置；
init：初始值，最后与两数组的内积向加；
binary_op1：二元运符，内积操作中外部的运算符号，默认为加法运算；
binary_op2：二元运符，内积操作中内的运算符号，默认为乘法运算；

(2).用法示例

a. 基本用法，计算两个数组的内积

将数组nums_1,nums_2视作两个相同维度的向量，inner_product()函数可以计算这两个向量（数组）的内积。
代码：

#include <iostream>
#include <vector>
#include <numeric>
using namespace std;
int main(int, char**) {
    vector<int> nums_1 = { 1,2,3 };
    vector<int> nums_2 = { 2,4,6 };
    // 28 = 0 + (1*2)+(2*4)+(3*6) = 2+8+18 = 28
    cout << inner_product(nums_1.begin(), nums_1.end(), nums_2.begin(), 0) << endl;
    // 33 = 5 + (1*2)+(2*4)+(3*6) = 2+8+18 = 33
    cout << inner_product(nums_1.begin(), nums_1.end(), nums_2.begin(), 5) << endl;
    return 0;
}

输出：

28
33

b. 自定义内积运算法则

默认两个数组的内积运算为：先各个元素相乘(内部运算符,binary_op2)然后再相加(binary_op1)。我们可以通过自定义binary_op1和binary_op2实现自定义的内积运算。示例如下：
代码：

#include <iostream>
#include <vector>
#include <numeric>
using namespace std;
int main(int, char**) {
    vector<int> nums_1 = { 1,2,3 };
    vector<int> nums_2 = { 2,4,6 };
    // 自定义内积操作
    // 外部运算依旧为加法，内部运算为 减法
    // -5 = 1 + (1-2)+(2-4)+(3-6) = -5
    cout << inner_product(nums_1.begin(), nums_1.end(), nums_2.begin(), 1, plus<int>(), minus<int>()) << endl;
    // 外部运算依旧为乘法，内部运算为 加法
    // 162 = 1*(1+2)*(2+4)*(3+6) = 3*6*9 = 162
    cout << inner_product(nums_1.begin(), nums_1.end(), nums_2.begin(), 1, multiplies<int>(), plus<int>()) << endl;
    return 0;
}

输出：

-5
162

4.partial_sum()函数介绍

partial_sum()函数可以计算数组的部分和，所谓部分和即为数组从首个元素到第i个元素的和。
例如：若nums为待计算数组，result为存放部分和的结果数组，那么：

result[0] = nums[0]
result[1] = nums[0] + nums[1]
result[2] = nums[0] + nums[1] + nums[2]
result[3] = nums[0] + nums[1] + nums[2] + nums[3]
result[4] = nums[0] + nums[1] + nums[2] + nums[3] + nums[4]
...

其实从以上示例中也可以看出，所谓的部分和即为数组的前缀和。

(1).函数定义

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

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).用法示例

a. 基本用法，计算数组的部分和(前缀和)

代码：

#include <iostream>
#include <vector>
#include <numeric>
using namespace std;
int main(int, char**) {
    vector<int> nums = { 1,2,3,4,5 };
    vector<int> results(nums.size(), 0);

    vector<int>::iterator iter = partial_sum(nums.begin(), nums.end(), results.begin());
    for (int i = 0; i < results.size(); i++) {
        cout << results[i] << " ";
    }
    cout << endl;
    return 0;
}

输出：

1 3 6 10 15

b. 自定义操作符binary_op

与前面accumulate(), adjacent_difference()函数类似，可以使用函数指针,函数对象与lambda表达式自定义求部分和的运算符号，此处不在赘述。
**需要注意的是：**结果容器results和原数组nums内的元素必须相同。
例如：假如nums内元素为pair<int, int>类型，我们需要计算nums[i].second的前缀和，那么results数组内的元素也必须为pair<int, int>类型，代码如下：

vector<pair<int, int>> nums;
for(int i=0; i<5; i++){
nums.push_back(pair<int, int>(i, 2*i));
}
vector<pair<int, int>> results(nums.size());
partial_sum(nums.begin(), nums.end(), results.begin(), [](const pair<int, int>&a, const pair<int, int>&b){
return pair<int, int>(a.second+b.second, 0);
});

5.iota()函数介绍

单从函数名字iota()并不能看出该函数的作用，因为该函数与前面其他函数的命名规则不同，该函数的名字iota并不是源自英文单词，而是来自希腊字母ι。该函数源于Ken Iverson发明的编程语言APL中的ι函数，其作用是生成一个以n为起始元素值，之后每个元素都增1，同时希腊字母ι也有极小，很小的一部分的意思。
因此，再C++中iota()函数的作用与APL中的ι函数类似，为使用以指定数值为起始，之后的元素依次增1的序列填充指定数组。

(1).函数定义

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

first,last：容器迭代器，待填充的数组；
val：初始元素值；

(2).用法示例

填充数组nums，令其第一个元素值为0，步长为1的递增数列。
代码：

#include <iostream>
#include <vector>
#include <numeric>
using namespace std;
int main(int, char**) {
    vector<int> nums(5, 0);
    iota(nums.begin(), nums.end(), 0);
    for (int i = 0; i < nums.size(); i++) {
        cout << nums[i] << " ";
    }
    return 0;
}

输出：

0 1 2 3 4

三、C++17新增的几个实用函数

1. gcd()函数

gcd()函数用来计算最大公约数(greatest common divisor)。
例如：gcd(12,18)返回6；

2. lcm()函数

lcm()函数用来计算最小公倍数(least common multiple)。
例如：gcd(12,18)返回36（36是12和18的最小公倍数）；

3. midpoint()函数

midpoint()函数用来计算整数、浮点数或指针的中点值。
例如：midpoint(2,5)返回3(2+5)/2取整等于3。

除了上面这三个函数之外，C++17中还新增了reduce(),transform_reduce(),inclusive_scan()等函数，详细信息读者可以查阅Standard library header 。

四、参考链接

[1]. cplusplus
[2]. cppreference Standard library header
[3]. Stack Overflow What does iota of std::iota stand for?
[4]. C++/C++11中头文件numeric的使用

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

[C++]＜numeric＞头文件介绍 的相关文章

  • C语言中命令行工具 (getopt和getopt_long)

    span class token macro property span class token directive hash span span class token directive keyword include span spa

  • C#与Java的比较

    关于java和C 争论不是一年两年了 贬低C 的文章也看过了很多 说一下个人见解 C 本身并不是不如java C 的优势在于学了之后在web和winform之间可以自由切换 web现在 net mvc已经效率很高了 企业级的应用现在很受欢迎

  • vs2010 和 vs2012同时安装遇到的问题

    安装VS2012后遇到的问题 悲剧的种子是在上个月初种下的 9月份微软发布了Visual Studio2012 xff08 发布会 xff09 xff0c 我是个对各种 新版本 极有偏好的人 xff0c 一看到新闻就立刻下载了VS2012

  • React警告：Received NaN for the `children` attribute. If this is expected, cast the value to a string.

    使用React框架时 xff0c 组件在使用 lt span gt Math abs goal goalInfo pretimes goal usergoalInfo cpt times lt span gt 这一语句时出现警告 xff1a

  • 持续请求/socket.io/?EIO=3&transport=polling&t=N8HrzIR

    项目基本介绍 xff1a 使用React xff0c webpack xff0c socket io client Node js Express socket io 等技术 xff0c 采用前后端分离开发 实现项目中的聊天室时遇到报错 x

  • node-xlsx 生成并下载有超链接的excel文件

    需求 xff1a 将微信小程序云数据库中的数据导出为excel文件 xff0c 文件按团队分为不同的sheet页 xff0c 首页汇总每个sheet页的数据总数 xff0c 并可点击跳转至对应的sheet页 下载时可选择今年某月份进行下载对

  • Vue通过v-for渲染的元素与$refs得到的实例对应不上

    开发时遇到一个bug xff1a 通过v for渲染出几个搜索条件组件 xff08 对应的数组数据记为selectList xff09 xff0c 通过其他方式修改了这些筛选条件对应的数据selectList xff0c 之后通过 refs

  • iView的Select 选择器选择失效

    问题 xff1a 给iView的Select赋的值通过接口获取 xff0c 得到数组 list xff0c 选择器的默认值 defaultValue 为数组list的第一个选择项 xff08 defaultValue 61 list 0 x

  • 不同路由对应同一组件页面

    在vue中 xff0c 当不同路由对应同一组件页面时会发生再次进入页面时不再重新渲染 xff08 为了更高效 xff0c 所以vue进行了复用 xff09 的问题 xff0c 整理一下解决办法 xff0c 如下 xff1a 方式一 Watc

  • /deep/样式穿透失效的原因和解决办法

    问题 xff1a vue页面中 xff08 样式使用less书写 xff09 xff0c 对iview的组件使用 deep 进行样式穿透修改默认样式 xff0c 发现在Google Chrome版本64上看样式修改成功 xff0c 但在火狐

  • 错误：ERROR in ./node_modules/_webpack-dev-server...Module not found: Error: Can't resolve 'webpack/hot

    学习webpack的途中总是困难重重 使用webpack dev server工具时 xff0c 运行cnpm run dev后报错 xff1a ERROR in node modules webpack dev server 64 2 1

  • 带参数的宏定义与有参函数的区别

    1 先介绍一下什么是宏定义 宏定义属于C语言编译系统中编译预处理中的一部分 xff08 但编译预处理不是C语言的语句 xff09 xff0c 其作用是为编译系统提供必要的前置信息 xff0c 告诉编译系统在源程序进行编译之前应该做些什么 它

  • UART接口控制器-RS-232的9脚接口

    RS 232常见引脚信号的定义 RXD 接收数据 xff0c TXD 发送数据 xff0c DTR 数据终端准备 xff0c GND 信号地 xff0c DSR 数据设备准备好 xff0c RTS 请求发送 xff0c CTS 清除发送 串

  • 去掉字符串最后一个字符的方法

    C 开发过程中一般都需要进行字符串的格式化处理 xff0c xff0c 以下提供去掉字符串最后一个字符的方法 如果是其他语言开发的话仅供参考有可能写法不一样 xff0c 但是意思是一样的 字符串 xff1a string s 61 34 1

  • C++11之lambda函数

    最近一直在看mesos的源代码 xff0c mesos中用到了很多C 43 43 11的新特性 xff0c lambda函数就是其中的一个 对于lambda函数简单的来说就是java中的匿名函数 语法定义 capture paramente

  • C++中两个类互相包含

    今天突然想起一个C 43 43 的问题 xff0c 如果一个类A包含类B的实例 xff0c 而实例B也包含另一个类A xff0c 这种方式的代码应该怎么写 xff0c 按照一般的开发者的想法的代码如下 xff1a 文件A h span cl

  • 命名空间

    命名空间的作用 命名空间是为了防止名字冲突提供更加可控的机制 命名空间分割了全局命名空间 xff0c 其中每一个命名空间是一个作用域 命名空间的定义 命名空间由三部分组成 xff0c 分别是namespace 空间名字和一系列由花括号括起来

  • STL中的swap函数

    swap函数执行会调用容器内数据类型的 xff0c 拷贝构造和赋值函数调用 对自定义类型使用STL algorithm中的swap函数 xff0c 会调用自定义的类型的拷贝构造函数一次 赋值函数两次 xff1b 自定义类型中没有定义那么就会

  • C++11之POD类型

    什么是POD类型 POD的全称叫做Plain Old Data xff0c 简单讲就是一个类或者一个结构体通过二进制拷贝之后还能保持其不变 xff0c 那么这个类型就是POD类型 什么类型属于POD类型 当一个类型具有平凡的定义和标准布局这

  • C++11之初始化成员变量

    C 43 43 98中的成员变量初始化 在声明类的时候 xff0c 对于静态类型并且是常量类型 xff0c 同时是枚举或者是整型的变量可以使用 61 在声明时初始化 对于不符合上述要求的静态变量可以在类外使用 61 进行初始化对于非静态类型

随机推荐

  • C++11之左值、纯右值和将亡值

    在C 43 43 11中所有的值一定属于左值 纯右值和将亡值三种值之一 xff0c 分别介绍一下这三种类型 左值与右值 在C 43 43 中定义左值与右值的比较标准的方法是根据其可以取地址来判断 左值就是可以对变量进行取地址或者有名字的变量

  • Skip List

    Skip List 是什么 我们常用数组和链表来组织数据 xff0c 对于已排序的数据 xff0c 数组的查询时间复杂度可以是 lgn 二分查找 xff0c 插入和删除都是 n 链表提供了一种更加灵活的组织方式 xff0c 插入和删除的时间

  • 程序员的自我修养--可执行文件的装载与进程

    进程的虚拟地址空间 C语言指针大小的位数与虚拟地址空间的地址位数相同 xff0c 即32位平台下进程的虚拟地址空间为4G由于程序在运行是处于操作系统的监管下 xff0c 进程的虚拟地址空间都在操作系统的掌握中 xff0c 只能使用操作系统分

  • C++11之继承构造函数

    问题场景 类的继承中 xff0c 如果子类想使用父类的构造函数 xff0c 则需要在子类的构造函数中声明使用父类的构造函数 xff0c 例子如下 xff1a span class hljs keyword struct span A A s

  • E95-DTU(4G01-485）数传电台的特点及其应用详解

    1 E95 DTU 4G01 485简介 E95 DTU 4G01 485 是采用 4G CAT1 方案的云数传电台 xff0c 电台支持微信小程序简单配对使用 可以显现一对一 一对多 多对多等复杂应用场景 由于采用了云技术 xff0c 数

  • STM32学习笔记（串口、IAP）

    串口 xff1a 一 USART ITConfig USART1 USART IT TXE ENABLE xff1a 只要发送寄存器为空 xff0c 就会一直有中断 xff0c 因此 xff0c 要是不发送数据时 xff0c 把发送中断关闭

  • C++中容器的优点和缺点

    顺序容器 连续存储 array 优点 随机访问 一步直接得到数据的首地址的访问方式 方便 开销低 速度快 缺点 容量在定义时就确定了 不能够改变 中间删除和插入比较麻烦 需要后面的元素都移动 vector 优点 随机访问方便 可以自动扩容

  • 硬件切换485电路

    485接口具有很好的抗噪音抗干扰 长距离传输和多站能力特性 xff0c 使其为工控行业首选串行接口 485规定的电气特性为2线 xff0c 半双工多点通信 它的电气特性是有线缆两端的电压差来决定的 由于半双工模式 xff0c 通讯时需要切换

  • 802.11 Authentication and Association

    The 802 11 standard provides a method for supplying different levels of access to different nodes in a wireless local ar

  • 串口通信与波特率

    原文出自微信公众号 小小的电子之路 串口是串行接口的简称 xff0c 串行接口是采用串行通信方式的接口 串行通信是一种将需要传输的数据由低位到高位一位一位地在一条传输线上逐个传输的通信方式 一 串行通信的数据格式 首先来了解一下串行通信的数

  • 无人机方向控制pitch yaw roll是什么 .。欧拉角定义

    http blog csdn net yuzhongchun article details 22749521 三维空间的右手笛卡尔坐标如图1所示 图1 在航空中 xff0c pitch yaw roll如图2所示 pitch是围绕X轴旋转

  • Java学习记录

    Java学习记录 第一个Java程序tips Java对象与类变量类型构造方法创建对象源文件声明规则八大基本数据类型引用类型常量类型转换 第一个Java程序 span class token keyword public span span

  • 在Windows上搭建http服务器（lighttpd)------中秋节大礼

    今天中秋节 xff0c 也算忙了一大天了 窗外月圆 xff0c 我是不是也该吟诵 露从今夜白 xff0c 月是故乡明 这样的佳句呢 xff1f 还好 xff0c 过几天国庆就要回家了 今天继续来聊聊http服务器吧 xff01 在前面的文章

  • EPG简介

    一 EPG简介 电子节目指南 Electronic Program Guide xff0c EPG xff0c 是指在符合MPEG 2 13818 1 的TS传输流中插入DVB标准定义的业务信息 Service Information xf

  • ROS学习笔记（五）

    本文是关于第14讲的学习内容总结 所以要完成的目标是 xff0c 用C 43 43 代码编程实现服务端 Server的作用就是给海龟发布指令的 xff0c Client的作用是来控制Server是否要给海龟发布指令 老师的解释是Client

  • 433M数传电台窄带无线通讯技术手册

    一 模块介绍 1 1特点介绍 E3A DTU 500 是 一款 频率 433M 无 线数传电 台 xff08 同时 具有RS232 RS485 接口 xff09 xff0c 透明传输方式 xff0c 工作在 425 450 5MHz 频段

  • [C++]按字节读取文件

    一 背景 本文介绍了如何使用C 43 43 按字节读取 txt文件 本文第二部分为代码实例和对代码的解释 xff0c 第三部分为本文的参考文章 二 代码实例 span class token macro property span clas

  • [STL]priority_queue多种方式自定义排序

    一 背景 在做leetcode题目时很多题都需要使用优先队列 xff08 堆 xff09 xff0c 并需要使用自定义数据类型 自定义有限队列的排序方式 本文对priority queue的自定义排序方式做了总结 本文可能并不能覆盖所有自定

  • [Pyplot] 绘制三维散点图使用颜色表示数值大小

    一 摘要 在进行数据可视化时 xff0c 对于一元函数f x 61 y数据我们可以使用二维平面图显示 xff0c x轴表示自变量 xff0c y轴表示函数值 xff1b 对于二元函数f x y 61 z数据我们也可以使用三维图可视化 xff

  • [C++]＜numeric＞头文件介绍

    一 摘要 C 43 43 的 lt numeric gt 头文件中包含了一系列可用于操作数值序列 xff08 sequences of numeric value xff09 的函数 xff0c 通过修改函数的参数类型也可以将这些函数应用到

热门标签