从0开始C++（六）：模板与容器的使用详讲

目录

一、模板

函数模板

实例

类模板

实例

二、容器

标准模板类STL

容器的概念

数组（array）

向量 (vector)

列表 (list)

队列 (queue)

双端队列 (deque)

集合 (set)

映射 (map)

哈希集合 (unordered_set)

哈希映射 (unordered_map)

三、迭代器

一、模板

模板是一种泛型编程的工具，它允许在编译时对代码进行参数化。使用模板可以编写通用的代码，可以适用于多种不同类型的数据，使得代码可以更加通用和灵活。通过使用模板，可以减少代码重复，提高代码的可重用性和可维护性。

模板的语法使用尖括号 < > 来定义模板参数，参数可以是类型参数或非类型参数。类型参数可以用来指定函数或类的参数类型，非类型参数可以用来指定常量或枚举值。

使用模板时，需要在每个参数前加上关键字 template ，并用尖括号< >将参数包裹起来。

C++模板由两种类型：函数模板和类模板。

函数模板

函数模板是一种让函数能够根据不同参数类型进行通用操作的方法。通过使用函数模板，可以在不重复编写相似函数的情况下，对不同类型的数据进行相同的操作。

实例
#include <iostream>
using namespace std;// 模板函数
template<typename T>  // 可以是class也可以是typename
T add(T a,T b)
{return a+b;
}int main()
{string str = "hello ";string str2 = "world";cout << add(12,32) << endl; // 44cout << add(str,str2) << endl; //hello worldreturn 0;
}

类模板

类模板是一种允许定义通用类的方法。类模板可以定义一个模板类，该类可以根据不同的参数类型生成不同的具体类。这样可以避免为每个具体类型编写单独的类。

实例
#include <iostream>using namespace std;// 模板类
template<class T>
class Test
{
private:T val;
public:Test(T v):val(v){}T get_val()const{return val;}void set_val(const T &val){this->val = val;}
};int main()
{Test<int> t1(20);cout << t1.get_val() << endl;t1.set_val(10);cout << t1.get_val() << endl;   // 10Test<double> t2(0.2);cout << t2.get_val() << endl; // 0.2t2.set_val(20.3);cout << t2.get_val() << endl;return 0;
}

二、容器

标准模板类STL

标准模板库（Standard Template Library，STL）是惠普实验室开发的一系列软件的统称。虽说它主要出现到了C++中，但是在被引入C++之前该技术就已经存在了很长时间。

STL的代码从广义上讲分为三类：algorithm（算法）、container（容器）和iterator（迭代器），几乎所有的代码都采用了模板类和模板函数的方式，这相比于传统的由函数和类组成的库来说提供了更好的代码重用机会。

容器的概念

容器是用来存储数据的集合，数据元素可以是任何类型（因为是使用模板实现）。C++标准库提供了多种容器类，每个容器类都有其特定的特点和适用场景。

常见的C++容器类包括：

  1. 数组 (array)：固定大小的连续存储空间，可以快速访问元素。

  2. 向量 (vector)：动态数组，可以根据需要调整大小，支持快速随机访问和在尾部插入/删除元素。

  3. 列表 (list)：双向链表，可以在任意位置插入/删除元素，但随机访问效率较低。

  4. 前向列表 (forward_list)：单向链表，与list类似，但删除操作效率更高。

  5. 堆栈 (stack)：后进先出 (LIFO) 的数据结构，只能在顶部插入/删除元素。

  6. 队列 (queue)：先进先出 (FIFO) 的数据结构，只能在尾部插入，在头部删除元素。

  7. 双端队列 (deque)：双向队列，可以在两端插入/删除元素，支持随机访问。

  8. 集合 (set)：有序的唯一元素集合，可以快速插入/删除元素，并支持快速查找。

  9. 映射 (map)：键-值对的集合，按照键的顺序进行排序，可以快速插入/删除元素，并支持以键进行查找。

  10. 哈希集合 (unordered_set)：无序的唯一元素集合，使用哈希函数实现，插入/删除/查找操作的平均时间复杂度为常数。

  11. 哈希映射 (unordered_map)：无序的键-值对集合，使用哈希函数实现，插入/删除/查找操作的平均时间复杂度为常数。

这些容器类提供了丰富的接口和功能，可以根据不同的需求选择合适的容器。另外，C++标准库还提供了算法库，可以方便地对容器中的元素进行各种操作和处理。

数组（array）

array是一种固定大小的连续内存空间，用于存储相同类型的对象。可以使用array类模板来创建数组，以下是array数组的常用操作方法：

1、创建array数组：

#include <array>
std::array<int, 5> myArray; // 创建一个具有5个整数元素的数组

2、获取数组大小：

std::array<int, 5> myArray;
int size = myArray.size(); // 获取数组的大小，返回值为5

3、访问数组元素：

std::array<int, 5> myArray;
myArray[0] = 10; // 使用下标操作符访问和修改数组元素
int value = myArray[1]; // 获取数组的第2个元素的值

4、数组赋值和初始化：

std::array<int, 5> myArray;
myArray = {1, 2, 3, 4, 5}; // 使用花括号列表进行赋值
std::array<int, 5> myArray2 = {6, 7, 8, 9, 10}; // 使用花括号列表进行初始化

5、数组迭代器操作：

std::array<int, 5> myArray = {1, 2, 3, 4, 5};
for (auto it = myArray.begin(); it != myArray.end(); ++it) {// 使用迭代器遍历数组元素std::cout << *it << " ";
}

6、判断数组是否为空：

std::array<int, 5> myArray;
bool isEmpty = myArray.empty(); // 如果数组为空，则返回true，否则返回false

7、获取数组首尾元素的引用：

std::array<int, 5> myArray = {1, 2, 3, 4, 5};
int& frontElement = myArray.front(); // 获取数组第一个元素的引用
int& backElement = myArray.back(); // 获取数组最后一个元素的引用

8、交换数组内容：

std::array<int, 5> myArray = {1, 2, 3, 4, 5};
std::array<int, 5> myArray2 = {6, 7, 8, 9, 10};
myArray.swap(myArray2); // 交换两个数组的内容

向量 (vector)

vector是一种动态数组，它可以自动调整大小，并且具有很多方便的操作方法。以下是vector向量的常用操作方法：

1、创建vector向量：

#include <vector>
std::vector<int> myVector; // 创建一个整数向量

2、获取向量大小：

std::vector<int> myVector;
int size = myVector.size(); // 获取向量的大小

3、向向量中添加元素：

std::vector<int> myVector;
myVector.push_back(10); // 在向量尾部添加一个元素

4、访问向量元素：

std::vector<int> myVector;
myVector[0] = 10; // 使用下标操作符访问和修改向量元素
int value = myVector[1]; // 获取向量的第2个元素的值

5、向量赋值和初始化：

std::vector<int> myVector;
myVector = {1, 2, 3, 4, 5}; // 使用花括号列表进行赋值
std::vector<int> myVector2 = {6, 7, 8, 9, 10}; // 使用花括号列表进行初始化

6、向量迭代器操作：

std::vector<int> myVector = {1, 2, 3, 4, 5};
for (auto it = myVector.begin(); it != myVector.end(); ++it) {// 使用迭代器遍历向量元素std::cout << *it << " ";
}

7、判断向量是否为空：

std::vector<int> myVector;
bool isEmpty = myVector.empty(); // 如果向量为空，则返回true，否则返回false

8、获取向量首尾元素的引用：

std::vector<int> myVector = {1, 2, 3, 4, 5};
int& frontElement = myVector.front(); // 获取向量第一个元素的引用
int& backElement = myVector.back(); // 获取向量最后一个元素的引用

9、删除向量中的元素：

std::vector<int> myVector = {1,

列表 (list)

list是一种双向链表，它可以动态地插入和删除元素，并且具有很多方便的操作方法。以下是list列表的一些常用操作方法：

1、创建list列表：

#include <list>
std::list<int> myList; // 创建一个整数列表

2、获取列表大小：

std::list<int> myList;
int size = myList.size(); // 获取列表的大小

3、向列表中添加元素：

std::list<int> myList;
myList.push_back(10); // 在列表尾部添加一个元素
myList.push_front(20); // 在列表头部添加一个元素

4、访问列表元素：

std::list<int> myList;
myList.front() = 10; // 获取和修改列表的第一个元素
int value = myList.back(); // 获取列表的最后一个元素的值

5、列表赋值和初始化：

std::list<int> myList;
myList = {1, 2, 3, 4, 5}; // 使用花括号列表进行赋值
std::list<int> myList2 = {6, 7, 8, 9, 10}; // 使用花括号列表进行初始化

6、列表迭代器操作：

std::list<int> myList = {1, 2, 3, 4, 5};
for (auto it = myList.begin(); it != myList.end(); ++it) {// 使用迭代器遍历列表元素std::cout << *it << " ";
}

7、判断列表是否为空：

std::list<int> myList;
bool isEmpty = myList.empty(); // 如果列表为空，则返回true，否则返回false

8、删除列表中的元素：

std::list<int> myList = {1, 2, 3, 4, 5};
myList.pop_back(); // 删除列表尾部的元素
myList.pop_front(); // 删除列表头部的元素

9、插入元素到指定位置：

std::list<int> myList = {1, 2, 3, 4, 5};
auto it = std::find(myList.begin(), myList.end(), 3); // 找到值为3的元素的迭代器
myList.insert(it, 10); // 在指定位置插入一个元素

10、移除指定值的元素：

std::list<int> myList = {1, 2, 3, 4, 5};
myList.remove(3); // 移除所有值为3的元素

队列 (queue)

queue是一种队列容器，它遵循先进先出（First-In-First-Out，FIFO）的原则。以下是queue队列的一些常用操作方法：

1、创建queue队列：

#include <queue>
std::queue<int> myQueue; // 创建一个整数队列

2、获取队列大小：

std::queue<int> myQueue;
int size = myQueue.size(); // 获取队列的大小

3、向队列尾部添加元素：

std::queue<int> myQueue;
myQueue.push(10); // 在队列尾部添加一个元素

4、从队列头部移除元素：

std::queue<int> myQueue;
myQueue.pop(); // 移除队列头部的元素

5、获取队列头部元素的值：

std::queue<int> myQueue;
int frontValue = myQueue.front(); // 获取队列头部元素的值

6、获取队列尾部元素的值：

std::queue<int> myQueue;
int backValue = myQueue.back(); // 获取队列尾部元素的值

7、判断队列是否为空：

std::queue<int> myQueue;
bool isEmpty = myQueue.empty(); // 如果队列为空，则返回true，否则返回false

8、清空队列中的元素：

std::queue<int> myQueue;
myQueue = {}; // 清空队列中的所有元素

双端队列 (deque)

在C++中，deque（双端队列）是一种支持在头部和尾部进行插入和删除操作的动态数组。以下是deque的一些常用操作方法：

1、创建deque双端队列：

#include <deque>
std::deque<int> myDeque; // 创建一个整数双端队列

2、获取双端队列大小：

std::deque<int> myDeque;
int size = myDeque.size(); // 获取双端队列的大小

3、向双端队列头部插入元素：

std::deque<int> myDeque;
myDeque.push_front(10); // 在双端队列头部插入一个元素

4、向双端队列尾部插入元素：

std::deque<int> myDeque;
myDeque.push_back(20); // 在双端队列尾部插入一个元素

5、从双端队列头部删除元素：

std::deque<int> myDeque;
myDeque.pop_front(); // 删除双端队列头部的元素

6、从双端队列尾部删除元素：

std::deque<int> myDeque;
myDeque.pop_back(); // 删除双端队列尾部的元素

7、获取双端队列头部元素的值：

std::deque<int> myDeque;
int frontValue = myDeque.front(); // 获取双端队列头部元素的值

8、获取双端队列尾部元素的值：

std::deque<int> myDeque;
int backValue = myDeque.back(); // 获取双端队列尾部元素的值

9、判断双端队列是否为空：

std::deque<int> myDeque;
bool isEmpty = myDeque.empty(); // 如果双端队列为空，则返回true，否则返回false

10、清空双端队列中的元素：

std::deque<int> myDeque;
myDeque.clear(); // 清空双端队列中的所有元素

集合 (set)

set（集合）是一种基于红黑树实现的有序集合容器，它存储唯一的元素，并且按照升序排序。以下是set的一些常用操作方法：

1、创建一个set集合：

#include <set>
std::set<int> mySet; // 创建一个整数集合

2、向集合中插入元素：

std::set<int> mySet;
mySet.insert(10); // 插入一个元素

3、从集合中删除元素：

std::set<int> mySet;
mySet.erase(10); // 删除指定元素

4、检查集合中是否存在元素：

std::set<int> mySet;
bool contains = mySet.count(10); // 如果集合中存在元素10，则返回true，否则返回false

5、获取集合中的元素个数：

std::set<int> mySet;
int size = mySet.size(); // 返回集合中元素的个数

6、遍历集合：

std::set<int> mySet;
for (const auto& element : mySet) {// 处理每个元素
}

7、判断集合是否为空：

std::set<int> mySet;
bool isEmpty = mySet.empty(); // 如果集合为空，则返回true，否则返回false

8、清空集合中的元素：

std::set<int> mySet;
mySet.clear(); // 清空集合中的所有元素

映射 (map)

map是一种基于红黑树实现的键值对映射容器，它存储唯一的键和对应的值，并根据键的升序进行排序。以下是map的一些常用操作方法：

1、创建一个map映射：

#include <map>
std::map<int, std::string> myMap; // 创建一个整数到字符串的映射

2、向映射中插入键值对：

std::map<int, std::string> myMap;
myMap.insert(std::make_pair(1, "one")); // 插入一个键值对

3、从映射中删除键值对：

std::map<int, std::string> myMap;
myMap.erase(1); // 删除指定键的键值对

4、访问映射中的值：

std::map<int, std::string> myMap;
std::string value = myMap[1]; // 获取键为1的值

5、检查映射中是否存在键：

std::map<int, std::string> myMap;
bool contains = myMap.count(1); // 如果映射中存在键1，则返回true，否则返回false

6、获取映射中的键值对个数：

std::map<int, std::string> myMap;
int size = myMap.size(); // 返回映射中键值对的个数

7、遍历映射中的键值对：

std::map<int, std::string> myMap;
for (const auto& pair : myMap) {int key = pair.first;std::string value = pair.second;// 处理每个键值对
}

8、判断映射是否为空：

std::map<int, std::string> myMap;
bool isEmpty = myMap.empty(); // 如果映射为空，则返回true，否则返回false

9、清空映射中的键值对：

std::map<int, std::string> myMap;
myMap.clear(); // 清空映射中的所有键值对

哈希集合 (unordered_set)

unordered_set是一种基于哈希表实现的集合容器，它存储唯一的值，并根据哈希值进行快速查找。以下是unordered_set的一些常用操作方法：

1、创建一个unordered_set哈希集合：

#include <unordered_set>
std::unordered_set<int> mySet; // 创建一个整数类型的哈希集合

2、向哈希集合中插入元素：

std::unordered_set<int> mySet;
mySet.insert(1); // 插入一个元素

3、从哈希集合中删除元素：

std::unordered_set<int> mySet;
mySet.erase(1); // 删除指定的元素

4、检查哈希集合中是否存在元素：

std::unordered_set<int> mySet;
bool contains = mySet.count(1); // 如果集合中存在元素1，返回true，否则返回false

5、获取哈希集合的大小：

std::unordered_set<int> mySet;
int size = mySet.size(); // 返回集合中元素的个数

6、遍历哈希集合的元素：

std::unordered_set<int> mySet;
for (const auto& element : mySet) {// 处理每个元素
}

7、判断哈希集合是否为空：

std::unordered_set<int> mySet;
bool isEmpty = mySet.empty(); // 如果集合为空，返回true，否则返回false

8、清空哈希集合中的元素：

std::unordered_set<int> mySet;
mySet.clear(); // 清空集合中的所有元素

哈希映射 (unordered_map)

unordered_map是一种基于哈希表实现的映射容器，它存储键值对，并根据键的哈希值进行快速查找。以下是unordered_map的一些常用操作方法：

1、创建一个unordered_map哈希映射：

#include <unordered_map>
std::unordered_map<std::string, int> myMap; // 创建一个键为字符串，值为整数的哈希映射

2、向哈希映射中插入键值对：

std::unordered_map<std::string, int> myMap;
myMap.insert({"apple", 10}); // 插入一个键为"apple"，值为10的键值对
myMap["banana"] = 20; // 插入一个键为"banana"，值为20的键值对

3、从哈希映射中删除键值对：

std::unordered_map<std::string, int> myMap;
myMap.erase("apple"); // 删除键为"apple"的键值对

4、访问和修改哈希映射中的值：

std::unordered_map<std::string, int> myMap;
int value = myMap["apple"]; // 获取键为"apple"的值
myMap["banana"] = 30; // 修改键为"banana"的值为30

5、检查哈希映射中是否存在键：

std::unordered_map<std::string, int> myMap;
bool contains = myMap.count("apple"); // 如果哈希映射中存在键"apple"，返回true，否则返回false

6、获取哈希映射的大小：

std::unordered_map<std::string, int> myMap;
int size = myMap.size(); // 返回哈希映射中键值对的个数

7、遍历哈希映射的键值对：

std::unordered_map<std::string, int> myMap;
for (const auto& pair : myMap) {std::string key = pair.first;int value = pair.second;// 处理每个键值对
}

8、判断哈希映射是否为空：

std::unordered_map<std::string, int> myMap;
bool isEmpty = myMap.empty(); // 如果哈希映射为空，返回true，否则返回false

9、清空哈希映射中的键值对：

std::unordered_map<std::string, int> myMap;
myMap.clear(); // 清空哈希映射中的所有键值对

三、迭代器

迭代器是一种用于遍历和访问容器中元素的对象。迭代器提供了一种通用的访问容器元素的方式，使得我们可以在不依赖具体容器类型的情况下进行遍历和操作。迭代器分为正向迭代器和反向迭代器两种类型，分别用于正向遍历和反向遍历容器。

1、迭代器的定义和获取： 迭代器可以通过容器的成员函数begin()和end()来获取。其中，begin()返回指向容器中第一个元素的迭代器，end()返回指向容器尾部的迭代器。

std::vector<int> myVector = {1, 2, 3, 4, 5};
std::vector<int>::iterator it;
for (it = myVector.begin(); it != myVector.end(); ++it) {std::cout << *it << " ";
}

2、使用迭代器访问容器元素： 通过解引用操作符*可以获取迭代器指向的元素的值。

std::vector<int> myVector = {1, 2, 3, 4, 5};
std::vector<int>::iterator it = myVector.begin();
std::cout << *it << std::endl; // 输出：1

3、使用迭代器修改容器元素： 通过解引用操作符*可以获取迭代器指向的元素的引用，从而可以修改容器中的元素。

std::vector<int> myVector = {1, 2, 3, 4, 5};
std::vector<int>::iterator it = myVector.begin();
*it = 10; // 修改第一个元素的值

4、迭代器的移动： 迭代器可以通过自增（++）或自减（--）来移动到容器中的下一个或上一个元素。

std::vector<int> myVector = {1, 2, 3, 4, 5};
std::vector<int>::iterator it = myVector.begin();
++it; // 移动到下一个元素
--it; // 移动到上一个元素

5、迭代器的比较： 使用比较操作符（==、!=等）可以比较两个迭代器的相对位置。

std::vector<int> myVector = {1, 2, 3, 4, 5};
std::vector<int>::iterator it1 = myVector.begin();
std::vector<int>::iterator it2 = myVector.end();
if (it1 == it2) {std::cout << "The iterators are equal." << std::endl;
} else {std::cout << "The iterators are not equal." << std::endl;
}

需要注意的是，在使用迭代器时，要确保迭代器指向的元素是存在的，避免越界访问。此外，当容器发生改变（元素的插入、删除等操作）时，迭代器可能会失效，因此在使用迭代器之前要先判断其是否有效。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/pingmian/34383.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

Unity | Shader基础知识(番外：模型的制作流程)

Unity | Shader基础知识(番外：模型的制作流程)

目录 一、前言 二、模型的诞生 三、模型的表面 四、模型的贴图 五、上完材质的模型 六、材质的来源 七、作者的碎碎念 一、前言 up发现&#xff0c;初学程序&#xff0c;除非你是美术&#xff0c;模型出生&#xff0c;要不然对这些都是萌萌哒&#xff08;蒙蒙哒&#x…
阅读更多...
从宏基因组中鉴定病毒序列（2）

从宏基因组中鉴定病毒序列（2）

Introduction 在环境微生物学和生态学研究中&#xff0c;宏基因组学&#xff08;Metagenomics&#xff09;技术的应用已经彻底改变了我们对微生物群落的理解。宏基因组学通过对环境样本中的全部遗传物质进行测序和分析&#xff0c;可以全面揭示微生物群落的组成、功能和相互作…
阅读更多...
Modbus转Profibus网关在汽车行业的应用

Modbus转Profibus网关在汽车行业的应用

一、前言 在当前汽车工业的快速发展中&#xff0c;汽车制造商正通过自动化技术实现生产的自动化&#xff0c;目的是提高生产效率和减少成本。Modbus转Profibus网关&#xff08;XD-MDPB100&#xff09;应用于汽车行业&#xff0c;主要体现在提升自动化水平、优化数据传输以及实…
阅读更多...
刷题之小欧的平均数（卡码网）

刷题之小欧的平均数（卡码网）

小欧的平均数 这道题不看解析的话完全没有思路&#xff0c;连题目都没读明白&#xff0c;甚至看了评论答出来了还是不知道为什么&#xff0c;有知道的朋友可以教教我 #include<iostream> using namespace std;int main() {int x,y,z;cin>>x>>y>>z;//…
阅读更多...
【机器学习 复习】第10章 聚类算法

【机器学习 复习】第10章 聚类算法

一、概念 1.聚类 &#xff08;1&#xff09;是无监督学习&#xff0c;其实无监督学习就是无中生有&#xff0c;不给你标准答案&#xff08;标签啊啥的&#xff09;&#xff0c;然后让你自己来。 &#xff08;2&#xff09;聚类就是这样&#xff0c;让机器自己根据相似特征把相…
阅读更多...
找出1000以内的所有的完数

找出1000以内的所有的完数

完数的概念&#xff1a;完数&#xff08;Perfect Number&#xff09;是一个正整数&#xff0c;它等于除了它本身以外所有正因子之和。例如&#xff0c;6的因子有1、2、3和6&#xff0c;其中1236&#xff0c;所以6是一个完数。 #include <stdio.h> // 函数用于计算一个数…
阅读更多...
怎么将图片压缩调小？在线压缩图片的4种快捷方法

怎么将图片压缩调小？在线压缩图片的4种快捷方法

压缩图片是日常很常用的一个图片处理功能&#xff0c;现在拍摄和制作的图片都比较大&#xff0c;在使用时经常会受到影响。在遇到无法上传、传输过慢的问题时会降低工作效率&#xff0c;所以掌握一招快速压缩图片是非常重要的。通过下面这篇文章来给大家介绍一下在线图片压缩的…
阅读更多...
Flutter ffi Failed to lookup symbol

Flutter ffi Failed to lookup symbol

iOS release版本&#xff0c;解决方式参考官方文档&#xff1a;在 iOS 中使用 dart:ffi 调用本地代码 如果debug版本也报这个错误&#xff0c;很可能是有多个.c文件&#xff0c;编译的时候没带上&#xff01; 假设你的ffi模块名字是 c_lib 对于Android端&#xff0c;需要修改…
阅读更多...
基于Pytorch框架构建AlexNet模型

基于Pytorch框架构建AlexNet模型

Pytorch 一、判断环境1.导入必要的库2.判断环境 二、定义字典1.定义字典 三、处理图像数据集1.导入必要的模块2.定义变量3.删除隐藏文件/文件夹 四、加载数据集1.加载训练数据集2.加载测试数据集3.定义训练数据集和测试集路径4.加载训练集和测试集5.创建训练集和测试集数据加载…
阅读更多...
Vue源码分析之Vue入口文件_vue打包后的入口文件是哪个

Vue源码分析之Vue入口文件_vue打包后的入口文件是哪个

return n * n; } square(“2”); // Error! //添加类型注释&#xff0c;现在 Flow 就能检查出错误&#xff0c;因为函数参数的期待类型为数字&#xff0c;而我们提供了字符串。 #### 1.2 Vue.js源码目录###### Vue.js 的源码都在 src 目录下&#xff0c;其目录结构如下&#xf…
阅读更多...
Vuex中的重要核心属性

Vuex中的重要核心属性

Vuex 是一个专为 Vue.js 应用程序开发的状态管理模式。它采用集中式存储管理应用的所有组件的状态&#xff0c;并以相应的规则保证状态以一种可预测的方式发生变化。 Vuex 的核心属性包括&#xff1a; State: State 是 Vuex 存储数据的地方&#xff0c;类似于组件中的 data。它…
阅读更多...
elementUI相关知识及搭建使用过程

elementUI相关知识及搭建使用过程

​​​​​​ 目录 ​​​​​​ 一.elementUI相关的知识 1.什么是elementUI 2.如何在创建的项目中使用elementUI的组件(1)安装 ​ (2)在项目的main.js中引入elementUI (3)使用elementui里的组件 一.elementUI相关的知识 1.什么是elementUI Element&#xff0c;一套为开…
阅读更多...
JavaScript第十二讲：DOM编程“创建，删除，替换，插入节点”

JavaScript第十二讲：DOM编程“创建，删除，替换，插入节点”

目录 1. 创建节点 2. 删除节点 3. 替换节点 4. 插入节点 使用appendChild() 使用insertBefore() 深入解析与注意事项 1. 创建节点 在HTML DOM中&#xff0c;我们通常使用JavaScript的document.createElement()方法来创建元素节点&#xff0c;使用document.createTextNo…
阅读更多...
MQTTX 1.10.0 发布：CLI高级文件管理与配置

MQTTX 1.10.0 发布：CLI高级文件管理与配置

MQTTX 1.10.0 版本现已发布&#xff01; 在本次更新中&#xff0c;CLI 版本在文件管理和配置功能方面进行了显著增强。主要更新包括&#xff1a;支持从文件中读取和写入消息、高级配置选项、文本输出模式、以及改进的日志记录。此外&#xff0c;桌面版本现在支持数据库重建&am…
阅读更多...
区块链的茶后杂谈

区块链的茶后杂谈

1.前言 读者小伙伴们好久不见&#xff0c;不知大家有没有想念作者&#xff1f;两个月前作者发布了一篇关于区块链技术和数字货币的文章&#xff0c;没想到获得了很多家人们的喜欢&#xff0c;作者很高兴大家也看好这一行业和技术领域&#xff0c;结合最近国际上发生的一些大事&…
阅读更多...
IDEA集成Maven

IDEA集成Maven

&#x1f4bb;博主现有专栏&#xff1a; C51单片机&#xff08;STC89C516&#xff09;&#xff0c;c语言&#xff0c;c&#xff0c;离散数学&#xff0c;算法设计与分析&#xff0c;数据结构&#xff0c;Python&#xff0c;Java基础&#xff0c;MySQL&#xff0c;linux&#xf…
阅读更多...
《Nest系列 - 3. 掌握常见Nest 装饰器，奠定坚实基础！！！！！！》

《Nest系列 - 3. 掌握常见Nest 装饰器，奠定坚实基础！！！！！！》

nest 一个核心就是依赖注入&#xff0c;而中的大部分功能都是通过装饰器来实现的&#xff0c;那什么是装饰器呢&#xff1f; 就是一个 xxx &#xff0c;诸如 Module&#xff0c;controller, Get, Post 那这样有什么好处呢&#xff1f; 可以把他理解成一个方法&#xff0c;在不改…
阅读更多...
物联网 IoT 收录

物联网 IoT 收录

物联网IoT日常知识收录 thingsboard, nodered是国际大品牌&#xff0c; iotgateway是国内的&#xff0c; 几个scada, pyscada, json-scada都还不错&#xff0c;比较一下。thingsboard-gateway是python系的&#xff0c;如果你愿意&#xff0c;可以用这个作为公司的物联网网关。…
阅读更多...
深入探索Jetpack数据绑定（DataBinding）

深入探索Jetpack数据绑定（DataBinding）

Jetpack的数据绑定&#xff08;DataBinding&#xff09;库为我们提供了一个强大而灵活的工具&#xff0c;用于将UI组件与数据源绑定在一起。本文将深入探讨数据绑定的高级用法&#xff0c;包括双向绑定、自定义Binding Adapter、使用LiveData和ViewModel&#xff0c;以及如何处…
阅读更多...
热虹吸管的传热计算

热虹吸管的传热计算

热对称管和热管通过使用中空管内的两相流体&#xff0c;在特定的距离上传输大量的热量。 更广泛使用的热管使用吸芯结构将液体输送回热端&#xff0c;而热虹吸管是一个简单的空心管&#xff0c;使用重力。 由于缺乏吸芯结构&#xff0c;使得热虹吸管比传统的热管便宜得多。 然…
阅读更多...
最新文章

Copyright @ 2022~2023