C++提高笔记（七）---STL常用算法（排序、拷贝和替换、算术生成、集合）

最新推荐文章于 2024-08-14 17:18:35 发布
最新推荐文章于 2024-08-14 17:18:35 发布
阅读量780 收藏 16
点赞数 22
分类专栏： C++ 文章标签： c++ 开发语言 算法 STL 泛型编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46359434/article/details/136820845
版权

（由于上篇笔记篇幅过长，故开新篇  继续记录算法笔记）

2.3常用排序算法

学习目标：掌握常用的排序算法

算法简介：

sort           //对容器内元素进行排序
random_shuffle //洗牌 指定范围内的元素随机调整次序
merge          //容器元素合并，并存储到另一容器中
reverse        //反转指定范围的元素

2.3.1 sort

功能描述：对容器内元素进行排序

sort属于开发中最常用的算法之一，需熟练掌握

函数原型：

sort(iterator beg, iterator end, _Pred);
// 按值查找元素，找到返回指定位置迭代器，找不到返回结束迭代器位置
// beg 开始迭代器
// end 结束迭代器
// _Pred 谓词
#include <iostream>
using namespace std;
#include<vector>
#include<algorithm>
#include<functional>
//常用排序算法 sort
void myPrint(int val)
{
    cout << val << " ";
}

void test01()
{
    vector<int>v;
    v.push_back(10);
    v.push_back(30);
    v.push_back(50);
    v.push_back(20);
    v.push_back(40);
    //利用sort进行升序 默认就是升序
    sort(v.begin(), v.end());
    for_each(v.begin(), v.end(), myPrint);
    cout << endl;
    //利用sort进行降序
    sort(v.begin(), v.end(),greater<int>());
    for_each(v.begin(), v.end(), myPrint);
    cout << endl;
}

int main()
{
    test01();
    system("pause");
    return 0;
}

输出结果：

10 20 30 40 50
50 40 30 20 10
请按任意键继续. . .

2.3.2 random_shuffle

功能描述：洗牌 指定范围内的元素随机调整次序

函数原型：

random_shuffle(iterator beg, iterator end);
// 指定范围内的元素随机调整次序
// beg 开始迭代器
// end 结束迭代器
#include <iostream>
using namespace std;
#include<vector>
#include<algorithm>
#include<ctime>
//常用排序算法 random_shuffle
void myPrint(int val)
{
    cout << val << " ";
}

void test01()
{
    //随机数种子 不然每次洗牌之后的顺序都一样
    srand((unsigned int)time(NULL));
    vector<int>v;
    for (int i = 0; i < 10; i++)
    {
        v.push_back(i);
    }
    //利用洗牌算法 打乱顺序
    random_shuffle(v.begin(), v.end());
    for_each(v.begin(), v.end(), myPrint);
    cout << endl;
}

int main()
{
    test01();
    system("pause");
    return 0;
}

输出结果：

9 2 8 1 5 6 4 0 7 3
请按任意键继续. . .

2.3.3 merge

功能描述：两个容器元素合并，并存储到另一容器中

注意：两个容器必须是有序的（而且顺序必须相同，不能一个升序，一个降序）

函数原型：

merge(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);
// 容器元素合并，并存储到另一容器中
// 注意： 两个容器必须是有序的
// beg1 容器1开始迭代器
// end1 容器1结束迭代器
// beg2 容器2开始迭代器
// end2 容器2结束迭代器
// dest 目标容器开始迭代器
#include <iostream>
using namespace std;
#include<vector>
#include<algorithm>
//常用排序算法 merge
void myPrint(int val)
{
    cout << val << " ";
}

void test01()
{
    vector<int>v1;
    vector<int>v2;
    for (int i = 0; i < 10; i++)
    {
        v1.push_back(i);
        v2.push_back(i + 10);
    }
    //目标容器
    vector<int>vTarget;
    //需要提前给目标容器分配空间
    //否则会报错
    vTarget.resize(v1.size() + v2.size());
    merge(v1.begin(), v1.end(), v2.begin(), v2.end(), vTarget.begin());
    for_each(vTarget.begin(), vTarget.end(), myPrint);
    cout << endl;
}

int main()
{
    test01();
    system("pause");
    return 0;
}

输出结果：

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
请按任意键继续. . .

2.3.4 reverse

功能描述：将容器内元素进行反转

函数原型：

reverse(iterator beg, iterator end);
// 反转指定范围的元素
// beg 开始迭代器
// end 结束迭代器
#include <iostream>
using namespace std;
#include<vector>
#include<algorithm>
//常用排序算法 reverse
void myPrint(int val)
{
    cout << val << " ";
}

void test01()
{
    vector<int>v1;
    for (int i = 0; i < 10; i++)
    {
        v1.push_back(i);
    }
    cout << "反转前：" << endl;
    for_each(v1.begin(), v1.end(), myPrint);
    reverse(v1.begin(), v1.end());
    cout << endl;
    cout << "反转后：" << endl;
    for_each(v1.begin(), v1.end(), myPrint);
    cout << endl;
}

int main()
{
    test01();
    system("pause");
    return 0;
}

输出结果：

反转前：
0 1 2 3 4 5 6 7 8 9
反转后：
9 8 7 6 5 4 3 2 1 0
请按任意键继续. . .

2.4常用拷贝和替换算法

学习目标：掌握常用的拷贝和替换算法

算法简介：

copy       //容器内指定范围的元素拷贝到另一容器中
replace    //将容器内指定范围的旧元素修改为新元素
replace_if //容器内指定范围满足条件的元素替换为新元素
swap       //互换两个容器的元素

2.4.1 copy

功能描述：容器内指定范围的元素拷贝到另一容器中

函数原型：

copy(iterator beg, iterator end, iterator dest);
// 按值查找元素，找到返回指定位置迭代器，找不到返回结束迭代器位置
// beg 开始迭代器
// end 结束迭代器
// dest 目标起始迭代器
#include <iostream>
using namespace std;
#include<vector>
#include<algorithm>
//常用拷贝和替换算法 copy
void myPrint(int val)
{
    cout << val << " ";
}

void test01()
{
    vector<int>v1;
    for (int i = 0; i < 10; i++)
    {
        v1.push_back(i);
    }
    vector<int>v2;
    v2.resize(v1.size());
    copy(v1.begin(), v1.end(), v2.begin());
    for_each(v2.begin(), v2.end(), myPrint);
    cout << endl; 
}

int main()
{
    test01();
    system("pause");
    return 0;
}

输出结果：

0 1 2 3 4 5 6 7 8 9
请按任意键继续. . .

2.4.2 replace

功能描述：将容器内指定范围的旧元素修改为新元素

函数原型：

replace(iterator beg, iterator end, oldvalue, newvalue);
// 将区间内旧元素 替换成 新元素
// beg 开始迭代器
// end 结束迭代器
// oldvalue 旧元素
// newvalue 新元素
#include <iostream>
using namespace std;
#include<vector>
#include<algorithm>
//常用拷贝和替换算法 replace
class MyPrint
{
public:
    void operator()(int val)
    {
        cout << val << " ";
    }
};

void test01()
{
    vector<int>v;
    v.push_back(20);
    v.push_back(30);
    v.push_back(50);
    v.push_back(30);
    v.push_back(40);
    v.push_back(20);
    v.push_back(10);
    v.push_back(20);
    cout << "替换前：" << endl;
    for_each(v.begin(), v.end(), MyPrint());
    //将20替换为99
    replace(v.begin(), v.end(), 20, 99);
    cout << endl;
    cout << "替换后：" << endl;
    for_each(v.begin(), v.end(), MyPrint());
    cout << endl; 
}

int main()
{
    test01();
    system("pause");
    return 0;
}

输出结果：

替换前：
20 30 50 30 40 20 10 20
替换后：
99 30 50 30 40 99 10 99
请按任意键继续. . .

2.4.3 replace_if

功能描述：将区间内满足条件的元素，替换成指定元素

注意：利用仿函数可以灵活筛选满足的条件

函数原型：

replace_if(iterator beg, iterator end, _pred, newvalue);
// 按条件替换元素，满足条件的替换成指定元素
// beg 开始迭代器
// end 结束迭代器
// _pred 谓词
// newvalue 替换的新元素
#include <iostream>
using namespace std;
#include<vector>
#include<algorithm>
//常用拷贝和替换算法 replace_if
class MyPrint
{
public:
    void operator()(int val)
    {
        cout << val << " ";
    }
};

class Greater03
{
public:
    bool operator()(int val)
    {
        return val >= 30;
    }
};

void test01()
{
    vector<int>v;
    v.push_back(10);
    v.push_back(40);
    v.push_back(20);
    v.push_back(40);
    v.push_back(30);
    v.push_back(50);
    v.push_back(20);
    v.push_back(30);
    cout << "替换前：" << endl;
    for_each(v.begin(), v.end(), MyPrint());
    //将大于等于30替换为99
    //利用仿函数可以灵活筛选满足的条件
    replace_if(v.begin(), v.end(), Greater03(), 99);
    cout << endl;
    cout << "替换后：" << endl;
    for_each(v.begin(), v.end(), MyPrint());
    cout << endl; 
}

int main()
{
    test01();
    system("pause");
    return 0;
}

输出结果：

替换前：
10 40 20 40 30 50 20 30
替换后：
10 99 20 99 99 99 20 99
请按任意键继续. . .

2.4.4 swap

功能描述：互换两个容器的元素

注意：一定要是同种容器

函数原型：

swap(container c1, container c2);
// 互换两个容器的元素
// c1容器1
// c2容器2
#include <iostream>
using namespace std;
#include<vector>
#include<algorithm>
//常用拷贝和替换算法 swap
class MyPrint
{
public:
    void operator()(int val)
    {
        cout << val << " ";
    }
};

void test01()
{
    vector<int>v1;
    vector<int>v2;
    for (int i = 0; i < 10; i++)
    {
        v1.push_back(i);
        v2.push_back(i + 100);
    }
    cout << "交换前：" << endl;
    for_each(v1.begin(), v1.end(), MyPrint());
    cout << endl;
    for_each(v2.begin(), v2.end(), MyPrint());
    cout << endl;
    cout << "------------------" << endl;
    cout << "交换后：" << endl;
    swap(v1, v2);
    for_each(v1.begin(), v1.end(), MyPrint());
    cout << endl;
    for_each(v2.begin(), v2.end(), MyPrint());
    cout << endl;
}

int main()
{
    test01();
    system("pause");
    return 0;
}

输出结果：

交换前：
0 1 2 3 4 5 6 7 8 9
100 101 102 103 104 105 106 107 108 109
------------------
交换后：
100 101 102 103 104 105 106 107 108 109
0 1 2 3 4 5 6 7 8 9
请按任意键继续. . .

2.5常用算术生成算法

学习目标：掌握常用的算术生成算法

注意：算术生成算法属于小型算法，使用时包含的头文件为#include<numeric>

算法简介：

accumulate // 计算容器元素累计总和
fill       // 向容器中添加元素

2.5.1 accumulate

功能描述：计算区间内 容器元素累计总和

函数原型：

accumulate(iterator beg, iterator end, value);
// 计算容器元素累计总和
// beg 开始迭代器
// end 结束迭代器
// value 起始值
#include <iostream>
using namespace std;
#include<vector>
#include<numeric>//别忘了包含此头文件
//常用算术生成算法 accumulate
void test01()
{
    vector<int>v;
    for (int i = 0; i <= 100; i++)
    {
        v.push_back(i);
    }
    //参数3是个起始累加值
    int total = accumulate(v.begin(), v.end(), 0);
    cout << "total = " << total << endl;
}

int main()
{
    test01();
    system("pause");
    return 0;
}

输出结果：

total = 5050
请按任意键继续. . .

2.5.2 fill

功能描述：向容器中填充指定的元素

函数原型：

fill(iterator beg, iterator end, value);
// 向容器中填充元素
// beg 开始迭代器
// end 结束迭代器
// value 填充的值
#include <iostream>
using namespace std;
#include<vector>
#include<numeric>//别忘了包含此头文件
#include<algorithm>
//常用算术生成算法 fill
class MyPrint
{
public:
    void operator()(int val)
    {
        cout << val << " ";
    }
};

void test01()
{
    vector<int>v;
    v.resize(10);
    //后期重新填充
    fill(v.begin(), v.end(), 100);
    for_each(v.begin(), v.end(), MyPrint());
    cout << endl;
}

int main()
{
    test01();
    system("pause");
    return 0;
}

输出结果：

100 100 100 100 100 100 100 100 100 100
请按任意键继续. . .

2.6常用集合算法

学习目标：掌握常用的集合算法

算法简介：

set_intersection // 求两个容器的交集
set_union        //求两个容器的并集
set_difference   // 求两个容器的差集

2.6.1 set_intersection

功能描述：求两个容器的交集

注意：

        两个集合必须是有序序列

        目标容器开辟空间需要从两个容器中取小值

        set_intersection返回值是交集中最后一个元素的位置

函数原型：

set_intersection(iterator begl, iterator end1, iterator beg2, iterator end2, iterator dest);
// 求两个集合的交集
// 注意:两个集合必须是有序序列
// beg1 容器1开始迭代器
// end1 容器1结束迭代器
// beg2 容器2开始迭代器
// end2 容器2结束迭代器
// dest 目标容器开始迭代器
#include <iostream>
using namespace std;
#include<vector>
#include<algorithm>
//常用集合算法 set_intersection
class MyPrint
{
public:
    void operator()(int val)
    {
        cout << val << " ";
    }
};

void test01()
{
    vector<int>v1;
    vector<int>v2;
    for (int i = 0; i < 10; i++)
    {
        v1.push_back(i);     //0-9
        v2.push_back(i + 5); //5-14
    }
    vector<int>vTarget;
    //目标容器需要提前开辟空间
    //最特殊情况，大容器包含小容器，开辟空间，取小容器的size即可
    vTarget.resize(min(v1.size(), v2.size()));
    //获取交集
    //返回值是个迭代器，是最后一个元素的位置
    vector<int>::iterator itEnd = set_intersection(v1.begin(), v1.end(), v2.begin(), v2.end(), vTarget.begin());
    //所以这里遍历的时候，容器末尾是itEnd
    for_each(vTarget.begin(), itEnd, MyPrint());
    cout << endl;
}

int main()
{
    test01();
    system("pause");
    return 0;
}

输出结果：

5 6 7 8 9
请按任意键继续. . .

2.6.2 set_union

功能描述：求两个集合的并集

注意：

两个集合必须是有序序列

目标容器开辟空间需要两个容器相加

set_union返回值既是并集中最后一个元素的位置

函数原型：

set_union(iterator begl, iterator end1, iterator beg2, iterator end2, iterator dest);
// 求两个集合的并集
// 注意：两个集合必须是有序序列
// beg1 容器1开始迭代翳
// end1 容器1结束迭代器
// beg2 容器2开始迭代器
// end2 容器2结束迭代器
// dest 目标容器开始迭代器
#include <iostream>
using namespace std;
#include<vector>
#include<algorithm>
//常用集合算法 set_union
class MyPrint
{
public:
    void operator()(int val)
    {
        cout << val << " ";
    }
};

void test01()
{
    vector<int>v1;
    vector<int>v2;
    for (int i = 0; i < 10; i++)
    {
        v1.push_back(i);     //0-9
        v2.push_back(i + 5); //5-14
    }
    vector<int>vTarget;
    //目标容器需要提前开辟空间
    //最特殊情况，大容器加上小容器，开辟空间，取两个容器的size和即可
    vTarget.resize(v1.size() + v2.size());
    //获取并集
    //返回值是个迭代器，是最后一个元素的位置
    vector<int>::iterator itEnd = set_union(v1.begin(), v1.end(), v2.begin(), v2.end(), vTarget.begin());
    //所以这里遍历的时候，容器末尾是itEnd
    for_each(vTarget.begin(), itEnd, MyPrint());
    cout << endl;
}

int main()
{
    test01();
    system("pause");
    return 0;
}

输出结果：

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14
请按任意键继续. . .

2.6.3 set_difference

功能描述：求两个集合的差集

注意：

求差集的两个集合必须的有序序列

目标容器开辟空间需要从两个容器取较大值

set_difference返回值既是差集中最后一个元素的位置

函数原型：

set_difference(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);
// 求两个集合的差集
// 注意：两个集合必须是有序序列
// beg1 容器1开始迭代器
// end1 容器1结束迭代器
// beg2 容器2开始迭代器
// end2 容器2结束迭代器
// dest 目标容器开始迭代器
#include <iostream>
using namespace std;
#include<vector>
#include<algorithm>
//常用集合算法 set_difference
class MyPrint
{
public:
    void operator()(int val)
    {
        cout << val << " ";
    }
};

void test01()
{
    vector<int>v1;
    vector<int>v2;
    for (int i = 0; i < 10; i++)
    {
        v1.push_back(i);     //0-9
        v2.push_back(i + 5); //5-14
    }
    vector<int>vTarget;
    //目标容器需要提前开辟空间
    //最特殊情况，两容器没有交集，开辟空间，取两个容器的最大size即可
    vTarget.resize(max(v1.size(), v2.size()));
    //获取差集
    //返回值是个迭代器，是最后一个元素的位置
    cout << "v1和v2的差集为：" << endl;
    vector<int>::iterator itEnd = set_difference(v1.begin(), v1.end(), v2.begin(), v2.end(), vTarget.begin());
    //所以这里遍历的时候，容器末尾是itEnd
    for_each(vTarget.begin(), itEnd, MyPrint());
    cout << endl;

    cout << "v2和v1的差集为：" << endl;
    itEnd = set_difference(v2.begin(), v2.end(), v1.begin(), v1.end(), vTarget.begin());
    //所以这里遍历的时候，容器末尾是itEnd
    for_each(vTarget.begin(), itEnd, MyPrint());
    cout << endl;
}

int main()
{
    test01();
    system("pause");
    return 0;
}

输出结果：

v1和v2的差集为：
0 1 2 3 4
v2和v1的差集为：
10 11 12 13 14
请按任意键继续. . .
正直和知府
关注
  • 22
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c++入门笔记-stl常用算法-拷贝和替换/算数生成/集合
weixin_43754049的博客
07-12 267
算法简介： copy //容器内指定范围的元素拷贝到另一容器中 replace //将容器内指定范围的旧元素修改为新元素 repalce_if //容器内指定范围满足条件的元素替换为新元素 swap //互换两个容器元素copy： 函数原型：copy(iterator beg, iterator end, iterator dest) //按值查找元素 找到返回指定位置迭代器 找不到返回结束迭代器位置
C++STL实验报告-迭代器和非变异算法
12-30
在本篇"C++ STL实验报告-迭代器和非变异算法"中，我们将深入探讨C++标准模板库（STL）中的几个核心概念，包括容器、迭代器和非变异算法。实验的目标是熟悉set、multiset、map和multimap这四种关联容器的使用，以及...
C++复习笔记--STL的常见拷贝替换、算术生成和集合算法的使用
牵一只蜗牛去散步
03-28 620
replace_if // 将容器指定范围内满足条件的旧元素替换为新元素。copy // 将容器内指定范围的元素拷贝到另一个容器当中；replace // 将容器内指定范围的旧元素替换为新元素。// newvalue 表示替换的新元素。//dest 表示目标容器的开始迭代器；//beg1 表示容器1的开始迭代器；//end1 表示容器1的结束迭代器；//beg2 表示容器2的开始迭代器；//end2 表示容器2的结束迭代器；//注：两个容器集合必须是有序序列！
c++学习笔记-提高篇-STL-常用六大算法（遍历、查找、排序、拷贝和替换、算术生成、集合算法）
qq_26572229的博客
01-04 1023
算法主要由头文件，常用的遍历算法、查找算法、排序算法、拷贝和替换算法、算术生成算法以及集合算法的使用和示例
STL常用算法笔记 -- 黑马程序员
weixin_74814064的博客
02-05 462
概念: ●返回类型的仿函数称为谓词●如果接受一个参数，那么叫做一元谓词●如果接受两个参数，那么叫做二元谓词参数列表类型分为两种●●
STL学习笔记--常用算法
VaIOReTto1的博客
12-13 148
STL学习笔记的一部分，主要用于个人记忆和复习，在代码和编辑习惯上也倾向于本人特点，主要专注于能读性和简便性。
C++学习笔记（10）---函数对象（仿函数）、STL遍历、查找、排序、拷贝与替换、算术生成、集合算法
plain_rookie的博客
08-18 457
1 函数对象 1.1 函数对象概念 （1）重载函数调用操作符的类，其对象常称为函数对象； （2）函数对象使用重载的()时，行为类似函数调用，也叫仿函数； 本质：函数对象(仿函数)是一个类，不是一个函数； 1.2 函数对象使用 特点：（1）函数对象在使用时，可以像普通函数那样调用，可以有参数，可以有返回值； （2）函数对象超出普通函数的概念，函数对象可以有自己的状态； （3）函数对象可以作为参数传递； //-------------练习1：函数对象（仿函数）----------------
【C++】学习笔记（十三）----STL中常用算法整理
weixin_50202509的博客
10-15 439
常用遍历算法for_each、transform 常用的查找算法find、find_if、adjacent_find、binary_search、count、cout_if 常用的排序算法sort、random_shuffle、merge、reverse 常用拷贝和替换算法copy、replace、replace_if、swap 常用算术生成算法accumulate、fill 常用的集合算法set_intersection、set_union、set_difference
C++笔记打卡第23天（STL常用算法）
weixin_57139639的博客
04-25 1156
C++笔记打卡第23天（STL常用算法）
C++核心编程：P19-＞STL----常用算法(下)
InnerPeaceHQ的博客
07-28 440
本系列文章为黑马程序员C++教程学习笔记，前面的系列文章链接如下 C++核心编程：P1-＞程序的内存模型 C++核心编程：P2-＞引用 C++核心编程：P3-＞函数提高 C++核心编程：P4-＞类和对象----封装 C++核心编程：P5-＞类和对象----对象的初始化和清理 C++核心编程：P6-＞类和对象----C++对象模型和this指针 C++核心编程：P7-＞类和对象----友元 C++核心编程：P8-＞类和对象----运算符重载 C++核心编程：P9-＞类和对象----继承 C++核心编程：P10
STL.rar_C++ STL_FSET-885_STL_stl源码_visual c
09-24
STL，全称为Standard Template Library（标准模板库），是C++编程语言中不可或缺的一部分，它为程序员提供了高效且灵活的数据结构和算法。STL的核心设计理念是泛型编程，即通过模板来实现数据结构和算法的通用性，...
C++ - SGI 版本 STL源码
10-25
STL（Standard Template Library，标准模板库）是C++编程语言中的一个重要组成部分，它提供了高效且灵活的数据结构和算法。SGI（Silicon Graphics, Inc.）公司在90年代为C++社区贡献了一个广受欢迎的STL实现，因其易...
C++实现oj算法代码-贪心算法.zip
10-28
- 学习并练习使用C++ STL的高级特性，如迭代器、函数对象和模板元编程，以提高代码效率和可读性。 总之，这个压缩包提供了C++实现的oj算法代码，主要关注贪心算法。通过研究这些代码，可以加深对贪心算法的理解，...
蓝桥杯常用C++STL函数笔记-两点水.docx
11-19
C++ Standard Template Library (STL) 是C++编程语言中一组强大的工具，提供了高效的数据结构和算法。以下是对蓝桥杯比赛中常用的C++ STL函数的详细解释： 一、Stack（栈） Stack 是一种后进先出（LIFO）的数据...
【C++】类的默认成员函数，构造函数、析构函数、拷贝构造函数、运算符重载
2402_82757055的博客
08-10 875
这篇我们继续学习C++类和对象部分，大概会说一下类的一些默认成员函数，构造函数、析构函数、拷贝构造函数、赋值运算符重载这些知识。
C++_基本语法笔记_模板
最新发布
qq_45629864的博客
08-14 245
思想是Java里的泛型（不确定用什么类型的数据）这里template这一句，意思是声明T是泛型，后面写用到泛型T的函数。建议都用应用场景：不同数据类型的交换函数。
【C语言】字符串操作函数详解
EleganceJiaBao的博客
08-14 478
这些头文件提供了字符串操作所需的函数声明。以下是常用字符串操作函数的详细讲解，包括每个函数的参数、返回值说明以及示例代码。每个函数的使用说明还包括了适当的表格以帮助理解其功能和用法。
如何对open62541.h/open62541.c的UA_Client进行状态（在线/掉线）监控
joyopirate的博客
08-12 180
可以发现，我们可以对UA_ClientConfig中的stateCallback进行赋值，也就是注册一个状态回调函数，从而获取客户端的状态变化。上位机这边会定时对PLC的某个opcua变量进行写操作。目前在利用open62541.h/open62541.c编写了一个与PLC进行OPCUA通讯的上位机程序。这个opcua库对多线程的处理比较差，很容易造成冲突。有没有什么办法可以监控client的状态，了解其是什么时候掉线，掉线了我就不写就行了。幸亏，是有这么一个回调函数的，参考官方的例子。
C++ STL 常用算法详解：遍历、查找、排序与更多
"这篇文档介绍了C++ STL中的常用算法，包括遍历、查找、排序、拷贝、替换和算术生成等操作。这些算法主要涉及`<algorithm>`、`<functional>`和`<numeric>`三个头文件。" 在C++ STL（标准模板库）中，算法是一组强大...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值