首页 > 编程语言 >C++11的一些语法

C++11的一些语法

时间:2024-11-01 11:30:49浏览次数:3  
标签:11 std int 元素 C++ 语法 vector vec include

vector 的用法

在 C++ 中,std::vector 是一个动态数组,它可以在运行时调整大小,std::vector 是 C++ 标准模板库 (STL) 中的一个重要容器类。

基本用法

在使用 std::vector 之前,需要包含头文件 <vector>

#include <iostream>
#include <vector>

当然,现在包含万能头 <bits/stdc++.h> 文件也是可以的。

1. 创建和初始化 std::vector

可以使用不同的方式来创建和初始化 std::vector

int main() {
    // 创建一个空的 vector
    std::vector<int> vec1;

    // 使用初始大小(默认值为0)
    std::vector<int> vec2(5); // 包含5个默认值(通常是0)

    // 使用初始大小和指定值
    std::vector<int> vec3(5, 10); // 包含5个值为10的元素

    // 使用初始化列表
    std::vector<int> vec4 = {1, 2, 3, 4, 5};

    return 0;
}

2. 添加和删除元素

std::vector 提供多种方法来添加和删除元素:

int main() {
    std::vector<int> vec;

    // 添加元素
    vec.push_back(1);
    vec.push_back(2);
    vec.push_back(3); // 现在 vec 包含 {1, 2, 3}

    // 在指定位置插入元素, 
    vec.insert(vec.begin() + 1, 4); // 在索引1插入4,现在 vec 为 {1, 4, 2, 3} 

    // 注意:插入元素是O(N)的时间复杂度,因为在插入之前需要移动该位置及右边的所有元素。
    

    // 删除元素
    vec.pop_back(); // 删除最后一个元素,现在 vec 为 {1, 4, 2}

    vec.erase(vec.begin() + 1); // 删除索引1的元素,现在 vec 为 {1, 2} 
    //删除元素也是$O(n)$的时间复杂度 

    return 0;
}

3. 访问元素

可以使用下标运算符或迭代器访问 std::vector 中的元素:

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};

    // 使用下标运算符访问元素
    std::cout << "First element: " << vec[0] << std::endl; // 输出: First element: 1

    // 使用 `.at()` 方法访问元素(带边界检查)
    std::cout << "Second element: " << vec.at(1) << std::endl; // 输出: Second element: 2

    // 使用迭代器访问元素
    for (auto it = vec.begin(); it != vec.end(); ++it) {
        std::cout << *it << " "; // 输出: 1 2 3 4 5 
    }
    std::cout << std::endl;

    return 0;
}

4. 常用成员函数

(1)、 resize(size_type count):更改 vector 的大小。
resize 用于调整 vector 的大小。
如果新的大小大于当前大小,vector 将会增加元素以达到这个新大小,新增的元素会被初始化为默认值。
如果新的大小小于当前大小,vector 将会删除多余的元素。

#include <iostream>  
#include <vector>  

int main() {  
    std::vector<int> vec = {1, 2, 3};  

    // 调整大小为 5,新增的元素为 0  
    vec.resize(5);  
    std::cout << "After resize to 5: ";  
    for (int num : vec) {  
        std::cout << num << " "; // 输出: 1 2 3 0 0  
    }  
    std::cout << std::endl;  

    // 调整大小为 2,丢弃后面的元素  
    vec.resize(2);  
    std::cout << "After resize to 2: ";  
    for (int num : vec) {  
        std::cout << num << " "; // 输出: 1 2  
    }  
    std::cout << std::endl;  

    return 0;  
}

(2)、 capacity():返回当前分配的容量。
capacity 返回 vector 当前可以容纳的元素数量,而不需要重新分配内存。它可能大于或等于 vector 的大小,表示内存的预分配。

#include <bits/stdc++.h>  
int main() {  
    std::vector<int> vec;  

    // 添加一些元素  
    vec.push_back(1);  
    vec.push_back(2);  
    vec.push_back(3);  

    std::cout << "Size: " << vec.size() << std::endl;       // 输出: 3  
    std::cout << "Capacity: " << vec.capacity() << std::endl; // 输出可能是 4 或更大  

    // 继续添加元素,超出当前容量  
    vec.push_back(4);  
    std::cout << "Size after adding more: " << vec.size() << std::endl; // 输出: 4  
    std::cout << "Capacity after adding more: " << vec.capacity() << std::endl; // 输出可能是 4 或更大  

    return 0;  
}

(3)、clear():移除所有元素。
清空 vector 中的所有元素,使得大小变为 0,但不会改变 capacity

(4)、empty():检查 vector 是否为空。
判断 vector 是否为空。如果 vector 的大小为 0,返回 true;否则返回 false

(5)、size():返回当前元素数量。

示例

```cpp
#include <iostream>
#include <vector>

int main() {
    // 创建一个 vector
    std::vector<int> vec;

    // 检查 vector 是否为空
    if (vec.empty()) {
        std::cout << "Vector is empty." << std::endl; // 输出: Vector is empty.
    }

    // 向 vector 添加一些元素
    vec.push_back(5);
    vec.push_back(10);
    vec.push_back(15);

    // 检查 vector 的状态
    std::cout << "Size: " << vec.size() << std::endl;       // 输出: Size: 3
    std::cout << "Capacity: " << vec.capacity() << std::endl; // 可能输出: Capacity: 4 或更大
    std::cout << "Is vector empty? " << (vec.empty() ? "Yes" : "No") << std::endl; // 输出: No

    // 清空 vector
    vec.clear();
    std::cout << "After clear -> Size: " << vec.size() << std::endl; // 输出: After clear -> Size: 0
    std::cout << "Is vector empty? " << (vec.empty() ? "Yes" : "No") << std::endl; // 输出: Yes

    // 再次检查容量
    std::cout << "Capacity after clear: " << vec.capacity() << std::endl; // 输出容量可能保持不变

    return 0;
}
```

### 输出结果

运行以上代码,将会得到以下输出(具体的 `capacity` 值可能因编译器和环境而异):

```
Vector is empty.
Size: 3
Capacity: 4
Is vector empty? No
After clear -> Size: 0
Is vector empty? Yes
Capacity after clear: 4
```
  • 在开始时,vector 为空,使用 empty() 返回 true
  • 添加元素后,empty() 返回 false,且 size() 返回当前元素数量。
  • 调用 clear() 后,vector 中的所有元素被移除,size() 变为 0,empty() 返回 true,但 capacity 可能不变。

小结

std::vector 是 C++ 中非常有用的容器,适合存储不定数量的元素。它提供了灵活的操作和高效的访问方式,适合动态处理数据。
它具有如下特点:

  • 支持数组下标
  • 可以动态调整大小
  • 比数组稍慢
  • 有许多自定义函数(方法)可以使用
  • 支持插入和删除操作,但如果插入和删除的位置不在末尾,则比较慢

C++ 中list的用法

在 C++ 中,std::list 是一个双向链表容器,它提供了快速的插入和删除操作,适合需要频繁插入和删除元素的场景。与 std::vector 不同,std::list 的元素在内存中不是连续存储的,因此访问元素的速度相对较慢,但在对元素进行插入和删除时表现得更有效率。

基本用法

在使用 std::list 之前,需要包含头文件 <list>

#include <iostream>
#include <list>

1. 创建和初始化 std::list

可以使用不同的方式来创建和初始化 std::list

int main() {
    // 创建一个空的 list
    std::list<int> myList;

    // 使用初始大小和指定值
    std::list<int> myList2(5, 10); // 将包含5个值为10的元素

    // 使用初始化列表
    std::list<int> myList3 = {1, 2, 3, 4, 5};

    return 0;
}

2. 添加和删除元素

std::list 提供多种方法来添加和删除元素:

push_back(); //在末尾插入
push_front(); //在开头插入
pop_back(); //在末尾删除
pop_front(); //在开头删除 
remove(a); //删除值为a的元素 

示例:

int main() {
    std::list<int> myList;

    // 添加元素
    myList.push_back(1); // 在末尾添加
    myList.push_back(2);
    myList.push_front(0); // 在开头添加

    // 现在 myList 为 {0, 1, 2}

    // 删除元素
    myList.pop_back(); // 删除末尾元素,现在 myList 为 {0, 1}
    myList.pop_front(); // 删除开头元素,现在 myList 为 {1}

    myList.remove(1); // 删除值为1的元素,现在 myList 为空

    return 0;
}

3. 访问元素

(1)、std::list 不支持随机访问(如下标运算符),但可以使用迭代器访问元素:

int main() {
    std::list<int> myList = {1, 2, 3, 4, 5};

    // 使用迭代器访问元素
    for (auto it = myList.begin(); it != myList.end(); ++it) {
        std::cout << *it << " "; // 输出: 1 2 3 4 5
    }
    std::cout << std::endl;

    return 0;
}

(2)、迭代器也支持自减运算, 可以从后往前访问链表,但是要注意初始值不能是end(),
因为end()表示的是链表尾部元素的下一个位置,那个位置是没有元素的**

#include <iostream>
#include <list>

int main() {
    // 创建一个 list,并添加一些元素
    std::list<int> myList = {1, 2, 3, 4, 5};

    // 使用迭代器从 list 的末尾迭代到开头
    for (auto p = myList.end(); p != myList.begin();) {
        --p; // 先将迭代器减少到最后一个有效元素
        std::cout << *p << " "; // 输出: 5 4 3 2 1
    }
    std::cout << std::endl;

    return 0;
}

(3)、 反向迭代器

可以使用 std::list 的反向迭代器 rbegin() 和 rend() 进行反向访问。

#include <iostream>  
#include <list>  

int main() {  
    // 创建一个 list,并添加一些元素  
    std::list<int> myList = {1, 2, 3, 4, 5};  

    // 使用 auto 和反向迭代器反向访问 list  
    std::cout << "Elements in the list in reverse order:" << std::endl;  
    for (auto it = myList.rbegin(); it != myList.rend(); ++it) {  
        std::cout << *it << " "; // 输出: 5 4 3 2 1  
    }  
    std::cout << std::endl;  
    return 0;  
}

4. 常用成员函数

  • size():返回当前元素数量。
  • empty():检查 list 是否为空。
  • clear():移除所有元素。
  • sort():对元素进行排序。
  • reverse():反转列表。
int main() {
    std::list<int> myList = {5, 2, 3, 1, 4};

    // 排序列表
    myList.sort(); // 现在 myList 为 {1, 2, 3, 4, 5}

    // 反转列表
    myList.reverse(); // 现在 myList 为 {5, 4, 3, 2, 1}

    std::cout << "Size: " << myList.size() << std::endl; // 输出: Size: 5

    // 清空列表
    myList.clear();
    std::cout << "Size after clear: " << myList.size() << std::endl; // 输出: Size after clear: 0

    if (myList.empty()) {
        std::cout << "List is empty." << std::endl;
    }

    return 0;
}

小结

std::list 是 C++ 中非常有用的容器,适合需要频繁插入和删除的场景。它提供了灵活的操作,但由于不支持随机访问,相较于 std::vector 在访问元素时可能会慢一些。了解其基本用法和成员函数,能够帮助更好地管理动态数据结构。

三、 C++ queue的用法

在 C++ 中,std::queue 是一个适用于先进先出(FIFO)原则的容器适配器,它通常用于处理数据流,确保元素以添加的顺序被访问。std::queue 只能在队尾添加元素(enqueue),并在队头删除元素(dequeue)。

要使用 std::queue,需要包含头文件 <queue>

基本用法

#include <iostream>
#include <queue>

int main() {
    // 创建一个空的 queue
    std::queue<int> myQueue;

    // 向队列中添加元素(enqueue)
    myQueue.push(1);
    myQueue.push(2);
    myQueue.push(3); // 现在队列为 {1, 2, 3}

    // 访问队列的头元素
    std::cout << "Front element: " << myQueue.front() << std::endl; // 输出: 1

    // 删除队列的头元素(dequeue)
    myQueue.pop(); // 现在队列为 {2, 3}

    // 再次访问头元素
    std::cout << "Front element after pop: " << myQueue.front() << std::endl; // 输出: 2

    // 检查队列是否为空
    if (!myQueue.empty()) {
        std::cout << "Queue size: " << myQueue.size() << std::endl; // 输出: 2
    }

    // 清空队列
    while (!myQueue.empty()) {
        myQueue.pop(); // 逐步删除元素
    }
    std::cout << "Queue size after clearing: " << myQueue.size() << std::endl; // 输出: 0
    return 0;
}

常用成员函数

  • push(const T& val):在队列的末尾添加一个元素。
  • pop():删除队列的头元素。
  • front():访问队列的头元素。
  • back():访问队列的尾元素。
  • empty():检查队列是否为空。
  • size():返回队列中元素的数量。

实际应用示例

#include <iostream>
#include <queue>

int main() {
    std::queue<std::string> taskQueue;

    // 添加任务到队列中
    taskQueue.push("Task 1");
    taskQueue.push("Task 2");
    taskQueue.push("Task 3");

    // 执行队列中的任务
    while (!taskQueue.empty()) {
        std::cout << "Processing: " << taskQueue.front() << std::endl; // 访问头元素
        taskQueue.pop(); // 执行完任务后移除
    }

    return 0;
}

优先队列的用法

在 C++ 中,std::priority_queue 是一种基于堆(heap)实现的容器适配器,它允许我们以优先级的方式访问元素。std::priority_queue 可以用于实现最大堆或最小堆,其默认行为是构建最大堆,确保最大的元素总是在队列的顶部。

要使用 std::priority_queue,需要包含头文件 <queue>

1、基本用法

(1)、默认是大根堆,

std::priority_queue<int> myque1;  //定义整数大根堆
std::priority_queue<double> myque2; // 定义double类型的大根堆

大根堆实例:

#include <iostream>
#include <queue>

int main() {
    // 创建一个空的优先队列
    std::priority_queue<int> pq;

    // 添加元素(默认是最大堆)
    pq.push(10);
    pq.push(30);
    pq.push(20);

    // 输出优先队列的顶端元素(最大元素)
    std::cout << "Top element: " << pq.top() << std::endl; // 输出: 30

    // 删除顶端元素
    pq.pop(); // 移除最大元素

    std::cout << "Top element after pop: " << pq.top() << std::endl; // 输出: 20

    // 检查优先队列是否为空
    if (!pq.empty()) {
        std::cout << "Size of the priority queue: " << pq.size() << std::endl; // 输出: 2
    }

    // 清空优先队列
    while (!pq.empty()) {
        pq.pop(); // 逐步删除元素
    }

    std::cout << "Size after clearing: " << pq.size() << std::endl; // 输出: 0

    return 0;
}

(2)、自定义优先级

priority_queue<int, vector<int>, less<int>> myq1; //定义整数大根堆
priority_queue<int, vector<int>, greater<int>>; //定义整数小根堆
priority_queue<doulbe, vector<double>, greater<double>>; //定义double类型的小根堆  

struct node{
    int a;
    bool operator < (const node &t) const{
        return a > t.a;
    }
};

std::priority_queue<node> myq; // a越小优先级越高 

小根堆示例:

#include <iostream>  
#include <list>  
#include <queue>
using namespace std;

struct node{
        int a;
        node(int t = 0) {a = t;}
        bool operator < (const node &t) const{
            return a > t.a;
        }
    };
int main() {  
    priority_queue<node> myq; // a越小优先级越高 
    myq.push(node(5));
    myq.push(node(3));
    myq.push(node(9));
    while(!myq.empty()){
        cout << myq.top().a << ' ' ; //输出3 5 9
        myq.pop();
    }
    return 0;  
}

常用成员函数

  • push(const T& value):在优先队列中插入一个新元素。
  • pop():删除优先队列中最高优先级的元素(顶部元素)。
  • top():访问最高优先级的元素。
  • empty():检查优先队列是否为空。
  • size():返回优先队列中元素的数量。

map的使用

C++中的std::map是一个关联容器,用于存储键值对(key-value pair)。这些键是唯一的,使用键可以快速查找对应的值。std::map通常实现为红黑树,以保持元素的有序性,使其支持对数时间复杂度的插入、删除和查找操作。

基本特性

  1. 键唯一:每个键只能出现一次。
  2. 有序性:元素按照键的顺序排列。
  3. 键值对:存储的元素为键值对,可以通过键来访问值。

包含头文件

在使用std::map之前,需要包含 <map> 头文件:

#include <map>

创建和初始化

可以使用花括号初始化,或者通过 insert 方法添加元素:

#include <iostream>
#include <map>

int main() {
    // 创建一个空的 map
    std::map<int, std::string> myMap;

    // 使用 insert 添加元素
    myMap.insert(std::make_pair(1, "Apple"));
    myMap.insert(std::pair<int, std::string>(2, "Banana"));
    
    // 使用花括号初始化
    std::map<int, std::string> anotherMap{
        {3, "Cherry"},
        {4, "Date"}
    };

    return 0;
}

插入元素

可以使用 insert 方法或 [] 运算符插入元素:

myMap[3] = "Orange"; // 使用 [] 运算符插入元素

访问元素

可以使用 [] 运算符或 at() 方法访问元素:

std::cout << "Key 1: " << myMap[1] << std::endl; // 输出: Apple
std::cout << "Key 2: " << myMap.at(2) << std::endl; // 输出: Banana

注意,当使用 [] 运算符访问不存在的键时,会插入一个默认值(如空字符串),而 at() 方法会抛出异常。

删除元素

可以使用 erase 方法删除元素:

myMap.erase(2); // 删除键为2的元素

查找元素

使用 find 方法来查找元素,返回一个迭代器。如果找到了元素,迭代器指向该元素;如果未找到,则指向 end()

auto it = myMap.find(1);
if (it != myMap.end()) {
    std::cout << "Found: " << it->second << std::endl; // 输出: Found: Apple
} else {
    std::cout << "Not found!" << std::endl;
}

遍历元素

可以使用范围 for 循环或迭代器来遍历 map

for (const auto &pair : myMap) {
    std::cout << "Key: " << pair.first << ", Value: " << pair.second << std::endl;
}

其他操作

  • 大小:可以使用 size() 方法获取元素数量。
  • 空检查:通过 empty() 方法检查 map 是否为空。

完整示例

以下是一个完整的示例,展示了上述所有特性:

#include <iostream>
#include <map>

int main() {
    // 创建一个 map
    std::map<int, std::string> myMap;

    // 插入元素
    myMap.insert({1, "Apple"});
    myMap[2] = "Banana";
    myMap[3] = "Cherry";

    // 访问元素
    std::cout << "Key 1: " << myMap[1] << std::endl; // 输出: Apple

    // 删除元素
    myMap.erase(2); // 删除键为2的元素

    // 查找元素
    auto it = myMap.find(2);
    if (it != myMap.end()) {
        std::cout << "Found: " << it->second << std::endl;
    } else {
        std::cout << "Key 2 not found!" << std::endl; // 输出: Key 2 not found!
    }

    // 遍历元素
    for (const auto &pair : myMap) {
        std::cout << "Key: " << pair.first << ", Value: " << pair.second << std::endl;
    }
    return 0;
}

set的使用

C++中的std::set是一个关联容器,用于存储唯一的元素。std::set是自动排序的,元素是以特定顺序存储的,且不允许重复元素。这个容器的实现通常是基于红黑树,因此支持\(O(logN)\)时间复杂度的插入、删除和查找操作。

基本特性

  1. 唯一性:集合中的元素是唯一的,不允许存储重复的值。
  2. 排序性:元素自动按升序(默认)排列,插入的顺序并不保证。
  3. 不可修改性:集合中的元素是只读的,不能直接修改已有的元素。

包含头文件

在使用 std::set 之前,需要包含 <set> 头文件:

#include <set>

创建和初始化

可以通过多种方式创建 std::set,例如:使用默认构造函数,使用花括号初始化等。

#include <iostream>
#include <set>

int main() {
    // 创建一个空的 set
    std::set<int> mySet;

    // 使用 insert 添加元素
    mySet.insert(10);
    mySet.insert(20);
    mySet.insert(30);
    //mySet:{10, 20, 30}

    // 使用花括号初始化
    std::set<int> Set2{3, 1, 4, 1, 5}; // Set2:{1,3,4,5}

    return 0;
}

插入元素

可以使用 insert 方法添加元素:

mySet.insert(15); // 插入新元素

注意,如果尝试插入一个已存在的元素,insert 不会变化集合,并返回一个指向该元素的迭代器。

删除元素

可以使用 erase 方法删除元素:

mySet.erase(20); // 删除元素20

查找元素

使用 find 方法来查找元素。如果找到了,返回指向该元素的迭代器,否则返回 end()

auto it = mySet.find(10);
if (it != mySet.end()) {
    std::cout << "Found: " << *it << std::endl; // 输出: Found: 10
} else {
    std::cout << "Not found!" << std::endl;
}

遍历元素

可以使用范围 for 循环或迭代器来遍历 set

for (const auto &elem : mySet) {
    std::cout << elem << " "; // 输出: 10 15 30
}

大小和空检查

可以使用 size() 方法获取元素数量,也可以使用 empty() 方法检查 set 是否为空:

std::cout << "Size: " << mySet.size() << std::endl; // 输出: Size: 3
if (mySet.empty()) {
    std::cout << "Set is empty!" << std::endl;
}

合并集合

可以通过 insert 方法将一个集合的元素插入到另一个集合中,自动处理重复值:

mySet.insert(anotherSet.begin(), anotherSet.end());

完整示例

以下是一个完整的示例,展示了上述所有特性:

#include <iostream>
#include <set>

int main() {
    // 创建一个 set
    std::set<int> mySet;

    // 插入元素
    mySet.insert(10);
    mySet.insert(20);
    mySet.insert(30);
    mySet.insert(20); // 尝试插入重复元素,忽略

    // 删除元素
    mySet.erase(20); // 删除元素20

    // 查找元素
    auto it = mySet.find(10);
    if (it != mySet.end()) {
        std::cout << "Found: " << *it << std::endl; // 输出: Found: 10
    } else {
        std::cout << "Not found!" << std::endl;
    }

    // 遍历元素
    std::cout << "Elements in mySet: ";
    for (const auto &elem : mySet) {
        std::cout << elem << " "; // 输出: 10 30
    }
    std::cout << std::endl;

    // 查看大小和空状态
    std::cout << "Size of mySet: " << mySet.size() << std::endl;
    if (mySet.empty()) {
        std::cout << "mySet is empty!" << std::endl;
    } else {
        std::cout << "mySet is not empty!" << std::endl;
    }

    return 0;
}

小结

std::set 是一个强大的数据结构,适用于需要高效查找和无重复元素的场景,如存储唯一值、集合操作等。掌握其基本用法可以帮助开发者高效管理和操作集合数据。

C++中匿名函数的使用

在 C++ 中,匿名函数通常被称为“Lambda 表达式”。它们允许在代码中定义未命名的函数,通常用于短小的、临时的功能。Lambda 表达式在 C++11 标准中引入,并在之后的标准中得到了增强。

Lambda 表达式的基本语法

[capture](parameters) -> return_type {
    // function body
}
  • capture:捕获外部变量的方式,可以是按值捕获或按引用捕获。
  • parameters:参数列表,如同普通函数。
  • return_type:返回类型,可以省略,编译器会自动推断。
  • function body:函数体。

示例

以下是一些使用 Lambda 表达式的示例。

1. 简单的 Lambda 表达式

#include <iostream>

int main() {
    auto greet = []() {
        std::cout << "Hello, World!" << std::endl;
    };

    greet();  // 调用 Lambda 表达式
    return 0;
}

2. 带参数的 Lambda 表达式

#include <iostream>

int main() {
    auto add = [](int a, int b) {
        return a + b;
    };

    int sum = add(5, 3);
    std::cout << "Sum: " << sum << std::endl; // 输出: Sum: 8
    return 0;
}

3. 捕获外部变量

#include <iostream>

int main() {
    int x = 10;
    int y = 20;

    auto add = [x, y]() {  // 按值捕获 x 和 y
        return x + y;
    };

    std::cout << "Sum: " << add() << std::endl; // 输出: Sum: 30
    return 0;
}

4. 按引用捕获

#include <iostream>

int main() {
    int x = 10;
    
    auto increment = [&x]() {  // 按引用捕获 x
        x++;
    };

    increment();
    std::cout << "Incremented x: " << x << std::endl; // 输出: Incremented x: 11
    return 0;
}

5. 结合 STL

Lambda 表达式常与 STL 算法结合使用,例如 std::sort

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<int> vec = {5, 3, 8, 1, 2};

    std::sort(vec.begin(), vec.end(), [](int a, int b) {
        return a < b;  // 自定义排序:升序
    });

    for (const auto &value : vec) {
        std::cout << value << " ";
    }
    std::cout << std::endl;
    return 0;
}

小结

Lambda 表达式在 C++ 中提供了一种方便且灵活的方式来定义匿名函数,能够简化代码并提高可读性。在使用时,需要合理选择捕获方式(按值或按引用)以避免潜在的错误。

标签:11,std,int,元素,C++,语法,vector,vec,include
From: https://www.cnblogs.com/hefenghhhh/p/18518936

相关文章

  • [luogu P11189] 水杯降温
    纯粹是自己太唐导致的我们发现其实这两种操作是独立的,并不需要考虑操作的相对顺序。这时候就有两种解决顺序:先子树加再链减先链减再子树加由于我一开始看错题了,所以我选了第一种思路,然后就爆炸了。所以我们选第二种,钦定\(d_x=a_{fa_x}-a_x\),那么最后子树加的时候......
  • 【C++】智能指针的正确使用方式
    本文将从这几方面讲解智能指针:智能指针的应用场景分析智能指针的性能分析:为什么shared_ptr性能比unique_ptr差指针作为函数参数时应该传,传值、传引用,还是裸指针?对于智能指针的使用,实际上是对所有权和生命周期的思考1.unique_ptr:专属所有权1.1unique_ptr介绍我们大......
  • laravel11:中间件传递参数
    一,官方的文档:参考地址:https://docs.golaravel.com/docs/middleware二,演示:功能:一个中间件负责验证用户是否已登录,    传递参数的作用是:在已登录基础是否验证真人身份核验,值为1时要核验,其他情况可以不用1,为中间件注册一个别名:bootstrap/app.php->withMidd......
  • C++之OpenCV入门到提高003:矩阵的掩膜(Mask)处理
    一、介绍今天是这个系列《C++之Opencv入门到提高》得第三篇文章。今天这篇文章也不难,主要介绍如何使用Opencv对图像进行掩膜处理,提高图像的对比度。在这个过程中,我们可以学到如何获取图像指针、如何处理像素值越界等问题。我们一步一个脚印的走,收获就会越来越多。虽然......
  • 【Anaconda】Anaconda3 下载与安装教程(Windows 11)
    引言Anaconda发行版是一个用于数据科学、机器学习和AI项目的平台。它包括数千个开源包,一个包和环境管理器,一个桌面应用程序,以及云服务。安装步骤下载安装程序访问官方Anaconda网站下载安装程序。https://www.anaconda.com/download/以管理员身份运行安装程序......
  • T533811 [SXZOI 2024 E] 哮
    [SXZOI2024E]哮题目背景是什么在黑夜嚎叫?题目描述有一个$n$个点,$m$条边的有向无环图。每条边上有边权。定义一条路径的权值为路径上所有边权的异或值。现在对于所有从节点$1$出发走到节点$n$的路径,输出这些路径的权值和。答案对$998244353$取模。输入格式第一......
  • 【YOLOv11改进 - 注意力机制】LSKA(Large Separable Kernel Attention):大核分离卷积注
    YOLOv11目标检测创新改进与实战案例专栏点击查看文章目录:YOLOv11创新改进系列及项目实战目录包含卷积,主干注意力,检测头等创新机制以及各种目标检测分割项目实战案例点击查看专栏链接:YOLOv11目标检测创新改进与实战案例@目录YOLOv11目标检测创新改进与实战案例专栏介......
  • PCL 法线微分(DoN)分割(C++详细过程版)
    目录一、概述二、代码实现三、结果展示本文由CSDN点云侠原创,原文链接,首发于:2024年11月1日。如果你不是在点云侠的博客中看到该文章,那么此处便是不要脸的抄袭狗。一、概述  法线微分(DoN)分割在PCL里有现成的调用函数,具体算法原理和实现代码见:PCL基于法线微分(D......
  • 基于Datawhale开源量化投资学习指南(11):LightGBM在量化选股中的优化与实战
    1.概述        在前几篇文章中,我们初步探讨了如何通过LightGBM模型进行量化选股,并进行了一些简单的特征工程和模型训练。在这一篇文章中,我们将进一步深入,通过优化超参数和实现交叉验证来提高模型的效果,并最终通过回测分析来验证我们所选股票的表现。2.LightGBM超......
  • C++《list》
    在本篇当中我们将学习STL中的list,在此list就是我们之前在数据结构学习过的链表,在本篇中我们要来了解list当中的成员函数该如何使用,由于list各个函数的接口和之前学习过的vector类型,因此在学习list的使用就较为轻松。在lis篇章中我们要重点了解的是在下一个篇章当中的list模拟实......