【C++】map和set的使用

最新推荐文章于 2024-07-12 20:28:37 发布
最新推荐文章于 2024-07-12 20:28:37 发布
阅读量920 收藏 24
点赞数 38
分类专栏： 高质量Ｃ++的学习 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_64826370/article/details/140234301
版权

前言：前面我们学习了STL中的string、vector、list等等，今天我们就进一步学习更复杂的容器，map和set。

💖 博主CSDN主页:卫卫卫的个人主页 💞
👉 专栏分类:高质量Ｃ++学习 👈
💯代码仓库:卫卫周大胖的学习日记💫
💪关注博主和博主一起学习!一起努力！
在这里插入图片描述

关联式容器于键值对

什么是关联式容器

C++中的关联式容器是一种可以存储键-值对的容器，它使用键来快速检索值。与序列式容器不同的是，其里面存储的是<key, value>结构的键值对（不懂的可以去看看上期的博客），在数据检索时比序列式容器效率更高。C++标准库提供了四种关联式容器：std::set、std::multiset、std::map和std::multimap。

  1. std::set：std::set是一个基于红黑树实现的有序集合，它存储唯一的元素。元素按照默认的比较函数进行排序，也可以通过自定义比较函数进行排序。

  2. std::multiset：std::multiset是一个基于红黑树实现的有序集合，它可以存储重复的元素。元素按照默认的比较函数进行排序，也可以通过自定义比较函数进行排序。

  3. std::map：std::map是一个基于红黑树实现的有序关联容器，它存储键-值对，并根据键进行排序。键是唯一的，如果插入重复的键，新的值将覆盖旧的值。

  4. std::multimap：std::multimap是一个基于红黑树实现的有序关联容器，它可以存储重复的键-值对。键是可以重复的，插入重复的键-值对会按顺序插入。

关联式容器提供了快速的元素查找操作，时间复杂度为O(log n)。它们还提供了插入和删除元素的操作，并且保持元素的有序性。

键值对

用来表示具有一一对应关系的一种结构，该结构中一般只包含两个成员变量key和value，key代表键值，value表示与key对应的信息。比如：现在要建立一个英汉互译的字典，那该字典中必然有英文单词与其对应的中文含义，而且，英文单词与其中文含义是一一对应的关系，即通过该应该单词，在词典中就可以找到与其对应的中文含义。

键值对- pair

在C++中，键值对可以使用pair模板类来表示，该类定义在头文件中。pair模板类包含两个公共成员变量first和second，分别表示键和值。

下面是一个使用pair的简单示例：

#include <iostream>
#include <utility>

int main() {
    std::pair<int, std::string> myPair; // 创建一个键值对对象

    myPair.first = 1; // 设置键的值
    myPair.second = "hello"; // 设置值的值

    std::cout << "Key: " << myPair.first << std::endl; // 输出键的值
    std::cout << "Value: " << myPair.second << std::endl; // 输出值的值

    return 0;
}

上述示例中，我们使用pair模板类创建了一个键值对对象myPair。然后，我们通过myPair的first和second成员变量分别设置了键和值的值。最后，我们通过访问myPair的first和second成员变量来输出键和值的值。

pair模板类还提供了一些有用的成员函数和操作符，例如make_pair函数用于创建一个pair对象，==和!=操作符用于比较两个pair对象是否相等等。我们可以根据具体的需求选择适合的成员函数和操作符来操作键值对。

pair的基本结构

在C++中，pair是一个模板类，定义在头文件中。它的基本结构如下：

template <class T1, class T2>
struct pair {
    typedef T1 first_type;     // 第一个元素的类型
    typedef T2 second_type;    // 第二个元素的类型

    T1 first;                  // 第一个元素
    T2 second;                 // 第二个元素

    // 构造函数
    pair();
    pair(const T1& x, const T2& y);
    template <class U, class V>
    pair(const pair<U, V>& p);

    // 比较操作符重载
    bool operator==(const pair& rhs) const;
    bool operator!=(const pair& rhs) const;
    bool operator<(const pair& rhs) const;
    bool operator>(const pair& rhs) const;
    bool operator<=(const pair& rhs) const;
    bool operator>=(const pair& rhs) const;
};

pair类有两个模板参数 T1 和 T2，分别表示第一个元素和第二个元素的类型。

pair类提供了默认构造函数 pair()，以及接受两个参数的构造函数 pair(const T1& x, const T2& y)，用于初始化pair对象。

此外，pair类还提供了一个模板构造函数 template <class U, class V> pair(const pair<U, V>& p)，用于将不同类型的pair对象进行转换。

对于比较操作，pair类重载了比较操作符，如 ==、!=、<、>、<=、>=，用于比较两个pair对象。

pair类的 first 成员变量表示第一个元素，second 成员变量表示第二个元素。

使用pair的时候，可以通过 .first 和 .second 成员变量来访问pair对象的两个元素。

make_pair

C++中的make_pair是一个函数模板，定义在头文件中。它用于快速创建一个pair对象，并自动推导出pair中模板参数的类型。

make_pair函数的定义如下：

template <class T1, class T2>
pair<T1, T2> make_pair(T1&& x, T2&& y);

make_pair函数接受两个参数，分别是第一个元素和第二个元素的值。函数会自动推导出pair中模板参数的类型，并返回一个pair对象。

使用make_pair函数可以方便地创建一个pair对象，例如：

int main() {
    int a = 1;
    double b = 3.14;

    auto myPair = make_pair(a, b);

    std::cout << myPair.first << ", " << myPair.second << std::endl;

    return 0;
}

在上面的例子中，通过make_pair(a, b)创建了一个pair对象，其中int类型的变量a被推导为pair的第一个元素，double类型的变量b被推导为pair的第二个元素。

make_pair可以方便地创建一个pair对象，避免了手动写出完整的pair对象的模板参数类型。

pair与make_pair的总结

下面列举了一些pair的常见用法：

  1. 作为函数的返回值：pair可以用来在函数中返回多个值，特别适用于需要返回两个不同类型的值的情况。
pair<int,string> getStudentInfo() 
{
    int id = 1234;
    string name = "Alice";
    return make_pair(id, name);//因此C++无法返回多个参数，通过pair可以解决这一缺陷
}

int main() {
    pair<int, string> student = getStudentInfo();
    cout << "ID: " << student.first <<endl;//输出1234
    cout << "Name: " << student.second << endl;//输出Alice
    return 0;
}
  1. 作为容器的元素：pair可以作为一些序列式容器（如vector、list等）的元素，以便存储多个值。
int main()
{
	vector<pair<int, string>> students;//存储在vector中
	students.push_back(make_pair(1, "Alice"));
	students.push_back(make_pair(2, "Bob"));
	for (auto& s1 : students) {
		cout << "ID: " << s1.first << ", Name: " << s1.second << endl;
	}

	list<pair<int, string>> grade;//存储在list中
	grade.push_back(make_pair(100, "weiweiwei"));
	grade.push_back(make_pair(90, "tang"));
	grade.push_back(make_pair(99, "zhou"));
	for (auto& s2 : grade) {
		cout << "ID: " << s2.first << ", Name: " << s2.second << endl;
	}

	return 0;
}

在这里插入图片描述

树形结构的关联式容器

根据应用场景的不桶，STL总共实现了两种不同结构的管理式容器：树型结构与哈希结构。树型结
构的关联式容器主要有四种：map、set、multimap、multiset。这四种容器的共同点是：使用平衡搜索树(即红黑树)作为其底层结果，容器中的元素是一个有序的序列。下面一依次介绍每一个容器。

1.set

什么是set

在C++中，std::set是一个容器类模板，它实现了一个有序的集合。std::set内部使用二叉搜索树(红黑树)数据结构来存储元素，并根据元素的键值进行自动排序。

  1. set是按照一定次序存储元素的容器
  2. 在set中，元素的value也标识它(value就是key，类型为T)，并且每个value必须是唯一的。
    set中的元素不能在容器中修改(元素总是const)，但是可以从容器中插入或删除它们。
  3. 在内部，set中的元素总是按照其内部比较对象(类型比较)所指示的特定严格弱排序准则进行
    排序。
  4. set容器通过key访问单个元素的速度通常比unordered_set容器慢，但它们允许根据顺序对
    子集进行直接迭代。
  5. set在底层是用二叉搜索树(红黑树)实现的。

set的常见使用方法

  1. 包含 头文件并使用 std::set 命名空间。
#include <set>
using namespace std;
  1. 声明和初始化 std::set 对象
set<int> mySet; // 创建一个空的 set 对象
set<int> mySet = {1, 2, 3, 4, 5}; // 使用 initializer list 初始化 set 对象
  1. 添加元素到 std::set
int main()
{
	set<int> mySet; // 创建一个空的 set 对象
	mySet.insert(10); // 添加元素到 set 中
	mySet.insert({ 20, 30, 40 }); // 添加多个元素到 set 中
	return 0;
}
  1. 获取 std::set 的大小
int main()
{

	set<int> mySet; // 创建一个空的 set 对象
	mySet.insert({ 20, 30, 40 }); // 添加多个元素到 set 中
	int size = mySet.size(); // 获取 set 的元素数量
	return 0;
}
  1. 遍历 std::set 中的元素

注：和搜索树一样，他的遍历就是升序

int main()
{
	set<int> mySet; // 创建一个空的 set 对象
	//set<int> mySet = { 1, 2, 3, 4, 5 }; // 使用 initializer list 初始化 set 对象
	mySet.insert(10); // 添加元素到 set 中
	mySet.insert({ 20, 0, 40 }); // 添加多个元素到 set 中
	int size = mySet.size(); // 获取 set 的元素数量
	for (const auto& element : mySet)//按照升序的方式遍历 
	{
		cout << element << " "; // 打印 set 中的元素
	}
	return 0;
}
  1. 查找 std::set 中的元素
int main()
{

	set<int> mySet; // 创建一个空的 set 对象
	mySet.insert(10); // 添加元素到 set 中
	mySet.insert({ 20, 0, 40 }); // 添加多个元素到 set 中
	auto it = mySet.find(10); // 查找元素 10 在 set 中的迭代器
	if (it != mySet.end()) {
		// 元素 10 存在于 set 中
		cout << *it << endl;
	}
	else
		cout << "不存在该元素" << endl;
	return 0;
}
  1. 删除 std::set 中的元素
int main()
{

	set<int> mySet; // 创建一个空的 set 对象
	mySet.insert(10); // 添加元素到 set 中
	mySet.insert({ 20, 0, 40 }); // 添加多个元素到 set 中
	mySet.erase(10); // 从 set 中删除元素 10
	mySet.clear(); // 清空 set 中的所有元素
	return 0;
}

上述示例演示了一些常见的std::set的用法。std::set还有其他更多功能和操作，可根据具体需求查阅C++文档以获得更详细的了解。

multiset

在C++中，std::multiset是一个容器类模板，它是一个有序的包含重复元素的集合（可以理解成允许重复值的set）。std::multiset允许在集合中插入重复的元素，并且会按照特定的比较准则自动进行排序。

以下是std::multiset的基本特性和使用方法：

  1. 包含头文件并使用std::multiset命名空间。
#include <set>
using namespace std;
  1. 声明和初始化std::multiset对象
int main()
{
	multiset<int>s1;//创建一个对象
	multiset<int> s2 = {10,20,30,40,50,10,20,30};//使用initerator list初始化
	return 0;
}
  1. 插入元素到multiset中
int main()
{
	multiset<int> s1;
	s1.insert(1);//插入数据
	s1.insert(3);
	s1.insert(0);
	s1.insert(5);
	s1.insert(2);
	return 0;
}
  1. 遍历multiset中的元素
int main()
{
	multiset<int> s1;
	s1.insert(1);
	s1.insert(3);
	s1.insert(0);
	s1.insert(5);
	s1.insert(2);
	for (auto it = s1.begin(); it != s1.end(); ++it)//遍历容器 
	{
		cout << *it << " ";
	}
	return 0;
}
  1. count(key)：返回multiset中值为key的元素的个数
int main()
{
	multiset<int> my_set = { 10,20,30,10,10,50 };
	int count = my_set.count(10);//查看10出现的次数
	cout << count << endl;
	return 0;
}
  1. find(key)：返回指向第一个值为key的元素的迭代器，如果找不到则返回end()迭代器
int main()
{
	multiset<int> myMultiset = { 10,20,30,10,10,50 };
	auto it = myMultiset.find(20);
	if (it != myMultiset.end()) {
		cout << "找到了: " <<  *it << endl;//查找20，找到了返回指向第一个值为key的元素的迭代器
	}
	else {
		cout << "未找到" << endl;//如果找不到则返回end()迭代器
	}

	return 0;
}
  1. erase(key)：删除所有值为key的元素
int main()
{
	multiset<int> myMultiset = { 10,20,30,10,10,50 };
	myMultiset.erase(20);//删除20，删除中序遍历出现的第一个20
	return 0;
}
  1. erase(iterator)：删除指定迭代器所指向的元素
int main()
{
	multiset<int> myMultiset = { 10,20,30,10,10,50 };
	auto it = myMultiset.begin();
	myMultiset.erase(it);//删除迭代器所指向的元素
	return 0;
}

9 . clear()：清空multiset中的所有元素

int main()
{
	multiset<int> myMultiset = { 10,20,30,10,10,50 };
	myMultiset.clear();//清空容器中所有的元素
	return 0;
}
  1. size()：返回multiset中的元素个数
int main()
{
	multiset<int> myMultiset = { 10,20,30,10,10,50 };
	int size = myMultiset.size();
	cout << size  << endl;//输出元素个数
	return 0;
}
  1. empty()：判断multiset是否为空
int main()
{
	multiset<int> myMultiset = { 10,20,30,10,10,50 };
	bool isEmpty = myMultiset.empty();//判断容器是否为空
	return 0;
}

std::multiset还可以使用自定义的比较函数进行排序，方法和使用std::set相同。可以提供一个比较函数作为multiset的第二个模板参数。

需要注意的是，std::multiset中的元素默认是按照升序进行排序的，如果需要自定义排序准则，可以提供一个比较函数作为multiset的第二个模板参数。

综上所述，std::multiset是一个有序的允许重复元素存在的容器，可以根据指定的排序准则对元素进行自动排序。它提供了插入、遍历、查找、删除等常用功能，通过成员函数可以对multiset进行操作和查询。

map

C++中的map是一种关联容器，它以键-值对（key-value）的形式存储数据。每个键都唯一，且根据键的大小进行自动排序。map是基于红黑树实现的，因此查找、插入和删除操作的时间复杂度为O(logN)。

下面是一些常见的使用方法和函数：

  1. 声明和初始化map：
#include <map>
#include <iostream>
using namespace std;
int main()
{
	map<string, int> my_map;
	map<string, int> My_map = { {"weiwei",90},{"zhou",100}, {"tang", 90}};
	return 0;
}
  1. 插入元素
int main()
{
	map<string, int> my_map;
	my_map.insert(make_pair("weiwei", 100));
	my_map.insert({ "weiwei", 90 });
	return 0;
}
  1. 访问元素
int main()
{
	map<string, int> my_map;
	my_map.insert(make_pair("weiwei", 100));
	my_map.insert({ "zhou", 90 });
	cout << my_map["weiwei"];//输出100,[]是输入对应的key值，然后输出对应的value
	return 0;
}
  1. 删除元素- 根据键删除对应的键值对
int main()
{
	map<string, int> my_map;
	my_map.insert(make_pair("weiwei", 100));
	my_map.insert({ "zhou", 90 });
	my_map.erase("weiwei"); // 根据键删除对应的键值对
	return 0;
}
  1. 查找元素
    如果find函数在map中找到了指定的键，则返回一个指向该键值对的迭代器；如果找不到指定的键，则返回指向map末尾的迭代器，即map::end()
int main()
{
	map<string, int> my_map;
	my_map.insert(make_pair("weiwei", 100));
	my_map.insert({ "zhou", 90 });
	auto it = my_map.find("weiwei");//查找key值为"weiwei"的迭代器的位置
	cout << it->second << endl;

	return 0;
}

6.遍历map

int main()
{
	map<string, int> my_map = { {"wei",90},{"zhou",100},{"tang",99} };
	map<string, int>::iterator it = my_map.begin();
	for (; it != my_map.end(); it++)
	{
		cout << it->first << " " << it->second << endl;
	}

	//范围for
	for (auto e : my_map)
	{
		cout << e.first << " " << e.second << endl;
	}
	return 0;
}
  1. 获取map的大小
int main()
{
	map<string, int> my_map = { {"wei",90},{"zhou",100},{"tang",99} };
	cout << my_map.size() << endl;//输出map的大小
	return 0;
}
  1. 运算符[ ]的用法

在C++的map中，可以使用[]运算符来访问和修改map中的元素。该运算符接受一个键作为参数，并返回与该键关联的值。如果该键不存在于map中，则会自动插入一个新键值对，并返回默认构造的值。

下面是使用[]运算符的示例代码：

#include <iostream>
#include <map>

int main() {
    std::map<std::string, int> myMap;

    // 插入键值对
    myMap["apple"] = 10;
    myMap["banana"] = 5;
    myMap["orange"] = 8;

    // 访问和修改值
    std::cout << "Number of apples: " << myMap["apple"] << std::endl;
    myMap["apple"] = 15;
    std::cout << "Updated number of apples: " << myMap["apple"] << std::endl;

    // 尝试访问不存在的键
    std::cout << "Number of pears: " << myMap["pear"] << std::endl;  // 会自动插入pear键并返回默认值0

    return 0;
}

上述代码中，我们使用[]运算符向map中插入了几个键值对，并通过[]运算符访问和修改了某些值。当我们使用[]访问一个不存在的键时，会自动插入该键并返回默认值。在上面的例子中，当我们访问"pear"键时，会自动插入"pear"键，并返回默认值0。

multimap

C++中的multimap是标准模板库(STL)中的一个关联容器，它可以存储多个键值对，并按键进行排序。与map不同的是，multimap允许存在重复的键。

multimap的特点如下:

  • 元素按照键的自然顺序进行排序
  • 允许存在重复的键
  • 插入元素的时间复杂度为O(log n)
  • 查找元素的时间复杂度为O(log n)

下面是一个使用multimap的示例:

#include <iostream>
#include <map>

int main() {
    std::multimap<int, std::string> myMultimap;

    // 插入元素
    myMultimap.insert(std::make_pair(1, "apple"));
    myMultimap.insert(std::make_pair(2, "banana"));
    myMultimap.insert(std::make_pair(3, "orange"));
    myMultimap.insert(std::make_pair(1, "grape")); // 插入重复的键

    // 遍历multimap
    for (auto it = myMultimap.begin(); it != myMultimap.end(); ++it) {
        std::cout << "Key: " << it->first << " Value: " << it->second << std::endl;
    }

    // 查找键为1的元素
    auto range = myMultimap.equal_range(1);
    for (auto it = range.first; it != range.second; ++it) {
        std::cout << "Found key 1: " << it->second << std::endl;
    }

    return 0;
}

上述代码创建了一个multimap，并插入了几个键值对，包括一个重复的键。然后，我们使用迭代器遍历multimap，打印出所有键值对。接着，我们使用equal_range函数查找键为1的元素，并使用迭代器遍历结果集。注意，由于multimap允许存在重复的键，所以查找结果是一个迭代器范围。

总结起来，multimap是一个按键排序并允许重复键的关联容器，可以用于存储和检索多个键值对。

好啦，今天的内容就到这里啦，下期内容预告AVL树的模拟实现.

结语：后面可以说是C++中最难的一部分了，大家一起加油。

🌏🗺️ 这里祝各位接下来的每一天好运连连 💞💞
卫卫周大胖;
关注
  • 38
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 10
    评论
专栏目录
map和set的模拟实现
06-06
它们在C++标准库中被广泛使用，提供了高效的键值对存储（Map）和唯一元素存储（Set）功能。本文将深入探讨如何通过封装红黑树来模拟实现Map和Set。 红黑树是一种自平衡二叉查找树，它的主要特性是每个节点都带有...
c++容器list、vector、map、set区别与用法详解
08-19
"c++容器list、vector、map、set区别与用法详解" c++容器是c++标准模板库（STL）中的一个重要组件，提供了多种数据结构的实现，包括list、vector、map、set等。这些容器的使用可以大大提高开发效率和代码可读性。 ...
Map和Set的区别
12-21
在C++标准模板库（STL）中，`Map` 和 `Set` 是两种关联容器，它们都提供了高效的数据存储和检索能力。然而，它们在数据结构、存储方式以及使用场景上有着显著的区别。 首先，`Map` 是一个键值对（Key-Value Pair）...
map和set的异同
09-28
map和set的异同map和set的异同map和set的异同map和set的异同
函数模板与类模板
程序员_小兵
07-12 1277
/交换int数据a = b;b = temp;//交换char数据a = b;b = temp;//问题：如果我要交换double类型数据，那么还需要些一个double类型数据交换的函数//繁琐，写的函数越多，当交换逻辑发生变化的时候，所有的函数都需要修改，无形当中增加了代码的维护难度//如果能把类型作为参数传递进来就好了，传递int就是Int类型交换，传递char就是char类型交换//我们有一种技术，可以实现类型的参数化---函数模板。
初始C++
2302_81016149的博客
07-08 792
在C语言我们学习函数的时候，我们学习过生命周期这个概念。那么，什么是生命周期呢？生命周期通常指的是一个对象或变量从创建到销毁所经历的时间段。那么，命名空间是什么？咱们可以这样理解：在这个空间的生命周期内，对这个空间内的全部标识符起一个名字，可对其进行引用，可类似与C语言中的结构体。#include<stdlib.h>//此处不包此头文件代码可正常运行，那该如何解决此处情况呢？int main()//此处编译不通过原因为：在不包头文件前为变量，包含后为函数。return 0;
Linux C | 管道open打开方式
I_feige的博客
07-12 195
1.
C++ 多态
wxk2227814847的博客
07-10 749
多态是C++语言的三大特性之一，另两个特性是封装和继承。多态性使得对象可以根据运行时的实际类型来表现出不同的行为，从而实现灵活和可扩展的设计。在软件开发过程中，多态能够提高代码的复用性和可维护性，减少重复代码，并提供更加抽象和通用的接口。本文将详细探讨C++中的多态，包括其定义、构成、虚函数、抽象类以及实现原理，帮助读者全面理解这一重要概念。
c++初阶学习----入门（上）
2302_80318761的博客
07-09 771
更加准确的说C++是在C语言的基础上发展而来的，它是完全兼容C语言的。大家还记得我们以前在vs里面创建项目的时候后缀打的是.c。当然写c++的代码vs还是适用的。只是后面我们创建c++项目的时候用的是.cpp了。
初识C++
friendhan2005的博客
07-12 231
C++的输入、输出和命名空间相关。
2024C++信息素养大赛-算法创意实践挑战_复赛真题（广东省）题目+参考答案和详细解析
m0_74586426的博客
07-12 248
2024C++信息素养大赛-算法创意实践挑战_复赛真题（广东省）题目+参考答案和详细解析
解释 C 语言中的函数重载机制（注意：C 语言不支持函数重载）？
技术笔记
07-11 335
虽然 C 语言不支持函数重载这一直接的特性，但通过合理地设计函数名、利用预处理器或使用函数指针和结构体等方法，我们仍然可以在一定程度上实现类似的功能，以满足不同参数类型的操作需求。然而，这些方法相较于真正的函数重载，在代码的简洁性和可读性上可能存在一定的不足。在实际编程中，选择哪种方法取决于具体的应用场景和编程需求。如果对函数重载有强烈的需求，可能考虑使用支持该特性的编程语言，如 C++。但对于一些简单的 C 语言项目，通过上述的模拟方法也能够有效地处理不同类型参数的函数调用问题。🎉相关推荐。
初识c++（引用，inline，nullprt）
suiyi_freely的博客
07-09 1008
引用不是新定义⼀个变量，而是给已存在变量取了⼀个别名，它和它引用的变量共用同⼀块内存空间。
C语言操作符详解
z317920的博客
07-11 463
目录一、操作符分类二、算术操作符三、赋值操作符四、关系操作符 五、条件操作符六、⼆进制和进制转换1.二进制 2.进制转换(1)2进制转10进制(2)10进制转2进制(3)2进制转8进制(4)2进制转16进制七、原码、反码、补码 八、移位操作符1.左移操作符2.右移操作符 九、位操作符1.按位与 &2.按位或 |3.按位异或 ^ 4.按位取反 ~ 十、单目操作符1.逻辑非操作符 ！ 2.自增++、自减-- 3.取地址符&、解引用符*、sizeof 3.1.取地址符& 3.2.解引
数学系C++ 继承派生多态 （十四十三）
m0_68339197的博客
07-08 314
可以使得派生类具有父类的各种属性和功能，而不需要再次编写相同的代码。类的继承：派生类继承了父类的特性（数据和函数）► 继承是可传递的：从父类继承的特性可以传递给新的子类► 继承方式：规定了如何访问从父类继承的成员► 继承方式有三种：public、protected、private► 派生类成员：从父类继承的成员+新增加的成员继承方式不同，访问控制不同 父类成员函数访问父类成员：正常访问 派生类成员函数访问派生类新增成员：正常访问 父类成员函数访问派生类新增成员：不能访问。
C++：CV::Point函数简介
Ethan_Rich的博客
07-08 438
cv::Point是 OpenCV 库中用于表示二维坐标系下点的一个基本数据类型。它提供了在图像处理、计算机视觉等领域中定位和操作点的能力。以下是关于cv::Point。
深入解析【C++ list 容器】：高效数据管理的秘密武器
小李很执着的博客
07-09 916
C++ 中的 list 容器是一个基于双向链表的序列式容器，适用于需要频繁插入和删除操作的场景，但不支持随机访问。list 提供了多种构造方法和丰富的操作接口，包括插入、删除、访问等。与 vector 相比，list 在插入和删除操作上更高效，但在随机访问和空间利用率上较差。
C++：哈希表
m0_61088872的博客
07-12 407
如果我们想要搜索这个数据，直接计算出这个数据的下标，然后就可以直接访问数组对应的位置，所以可以用O(1)的复杂度直接找到数据。当这个哈希表越满，我们查找数据的效率就越低，甚至说：如果查找一个不存在的数据，我们可能要用O(N)的复杂度遍历整个哈希表.因此我们因该把哈希表的负载率控制在一定值，当超过一定值，我们就要进行扩容操作。闭散列，也叫做开放定址法，当发生哈希冲突时，如果哈希表没有被装满，说明哈希表中还有空位置，那么我们可以把发生冲突的数据放到下一个空位置去。转化的函数，被写为了一个模板，而这个。
鸿蒙开发：Universal Keystore Kit（密钥管理服务）【密钥删除(C/C++)】
最新发布
m0_70748845的博客
07-12 234
为保证数据安全性，当不需要使用该密钥时，应该删除密钥。
C++map和set
03-31
C++中的map和set是两种常用的关联容器，它们都是基于红黑树实现的。 1. map： - map是一种键值对的容器，每个元素都包含一个键和一个值。 - map中的键是唯一的，且按照一定的顺序进行排序，默认是按照键的升序排列。 - 可以通过键来快速查找对应的值，因此在需要根据键进行查找、插入和删除操作时，map是一个很好的选择。 - 使用map需要包含头文件<map>。 2. set： - set是一种存储唯一元素的容器，它自动根据元素的值进行排序，默认是按照升序排列。 - set中的元素是唯一的，不允许重复。 - 可以通过set来快速查找元素，因此在需要判断某个元素是否存在时，set是一个很好的选择。 - 使用set需要包含头文件<set>。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 10
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

卫卫周大胖;

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值