1、memset()函数

1.1 基本介绍

1. 定义在头文件<cstring>中
2. 主要作用是对一块内存区域进行设置值的操作

1.2 函数原型

void *memset(void *str, int c, size_t n);

• str：指向要填充的内存块的指针
• c：要设置的值。该值以int形式传递，但函数在填充之前会将这个值转换为unsigned char
• n：要设置的字节数
• 返回值：返回指向内存块str的指针

1.3 常见用法

1.3.1 初始化数组

可以用来快速地将数组元素设置为0或其他相同的值

1.3.2 清空结构体或类对象

当需要重置结构体或类对象时，可以使用memset()将其所有成员变量设为0

1.3.3 性能优化

对于大量数据的初始化，memset()因为其底层实现通常是高度优化的，可能比手动循环赋值更快

1.4 基础用法

• 初始化一个整数数组

#include <iostream>
#include <cstring> // 必须包含此头文件

int main() {
    int numbers[5];
    
    // 使用 memset 将数组每个元素设置为0
    // 注意: memset 以字节为单位操作，因此这里每个int(4字节)都被设置为0
    memset(numbers, 0, sizeof(numbers));
    
    // 输出数组内容，验证是否全部被设置为0
    for(int i = 0; i < 5; ++i) {
        std::cout << "numbers[" << i << "] = " << numbers[i] << std::endl;
    }
    
    return 0;
}

2、swap()函数

2.1 基本介绍

1. 定义在头文件<utility>中
2. 主要作用是用于交换两个变量值

2.2 函数原型

void std::swap(T& a, T& b);

• a：要交换值的第一个变量的引用
• b：要交换值的第二个变量的引用

2.3 常见用法

2.3.1 交换两个变量的值

最基本的应用场景

2.3.2 交换容器内容

对于STL容器，除了使用通用的swap函数外，还可以调用容器自身的swap方法，这通常是更高效的选择

2.3.3 自定义类型

如果需要对自定义类型进行交换操作，可以通过重载swap函数来提高效率或者实现特定逻辑

2.4 基础用法

2.4.1 基本类型交换

#include <iostream>
#include <utility> // 包含std::swap

int main() {
    int a = 5, b = 10;
    std::cout << "Before swap: a = " << a << ", b = " << b << std::endl;

    std::swap(a, b); // 使用std::swap交换a和b的值

    std::cout << "After swap: a = " << a << ", b = " << b << std::endl;
    return 0;
}

2.4.2 STL容器交换

#include <iostream>
#include <vector>
#include <utility> // 包含std::swap

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

    std::cout << "Before swap:" << std::endl;
    std::cout << "vec1 contains:";
    for(auto& i : vec1) std::cout << ' ' << i;
    std::cout << "\nvec2 contains:";
    for(auto& i : vec2) std::cout << ' ' << i;
    std::cout << std::endl;

    // 交换vec1和vec2的内容
    vec1.swap(vec2); // 或者使用std::swap(vec1, vec2);

    std::cout << "After swap:" << std::endl;
    std::cout << "vec1 contains:";
    for(auto& i : vec1) std::cout << ' ' << i;
    std::cout << "\nvec2 contains:";
    for(auto& i : vec2) std::cout << ' ' << i;
    std::cout << std::endl;

    return 0;
}

3、reverse()函数

3.1 基本介绍

1. 定义在头文件<algorithm>中
2. 主要作用是用于反转序列容器（如vector，string，deque，array等）中的元素顺序

3.2 函数原型

void reverse(Iterator first, Iterator last);

• first：要反转范围的初始位置
• last：要反转范围的结束位置（但不包括last所指向的元素）。换句话说，它是半开区间[first, last)中最后一个元素的下一个位置

3.3 常见用法

3.3.1 反转数组或向量

可以用来快速地将一个数组或向量中的元素顺序颠倒

3.3.2 字符串处理

对于std::string类型的数据，reverse()可以用来反转字符串内容

3.3.3 自定义容器

如果自定义的容器支持双向迭代器，也可以使用reverse()来反转其中的元素

3.4 基础用法

3.4.1 反转std::vector<int>

#include <iostream>
#include <vector>
#include <algorithm> // 包含reverse函数

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

    std::cout << "Original vector: ";
    for(int i : vec) {
        std::cout << i << ' ';
    }
    std::cout << std::endl;

    std::reverse(vec.begin(), vec.end()); // 使用reverse函数反转vector

    std::cout << "Reversed vector: ";
    for(int i : vec) {
        std::cout << i << ' ';
    }
    std::cout << std::endl;

    return 0;
}

3.4.2 反转std::string

#include <iostream>
#include <string>
#include <algorithm> // 包含reverse函数

int main() {
    std::string str = "hello world";

    std::cout << "Original string: " << str << std::endl;

    std::reverse(str.begin(), str.end()); // 使用reverse函数反转字符串

    std::cout << "Reversed string: " << str << std::endl;

    return 0;
}

4、unique()函数

4.1 基本介绍

1. 定义在头文件<algorithm>中
2. 主要作用是用于移除给定范围内的连续重复元素，只保留每个重复序列的第一个实例
3. 时间复杂度为O(n)

4.2 函数原型

ForwardIt unique(ForwardIt first, ForwardIt last);
ForwardIt unique(ForwardIt first, ForwardIt last, BinaryPredicate p);

• first，last：定义了要处理的元素范围。这个范围是半开区间[first, last)，意味着包含 first指向的元素，但不包括last指向的元素
• BinaryPredicate p：可选参数，用于自定义比较规则，默认使用operator==

4.3 常见用法

4.3.1 移除连续重复项

这是最直接的应用场景，适用于任何支持双向迭代器的容器（如vector，deque等）

4.3.2 结合erase使用

为了实际删除容器中多余的元素，通常会将unique的返回值与erase方法结合使用

4.3.3 自定义比较逻辑

通过提供第三个参数，可以指定不同的比较方式来决定哪些元素被认为是重复的

4.4 基础用法

4.4.1 移除std::vector<int>中的连续重复项

#include <iostream>
#include <vector>
#include <algorithm> // 包含unique和sort函数

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

    // 首先对vector进行排序，因为unique只能移除相邻的重复项
    std::sort(vec.begin(), vec.end());

    // 使用unique移除连续重复项
    auto last = std::unique(vec.begin(), vec.end());

    // 删除多余的元素
    vec.erase(last, vec.end());

    // 输出结果
    for(int i : vec) {
        std::cout << i << " ";
    }
    std::cout << std::endl;

    return 0;
}

4.4.2 使用自定义比较函数

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

bool customCompare(int a, int b) {
    return (a % 3) == (b % 3); // 自定义比较规则，这里按模3的结果分组
}

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

    // 使用unique配合自定义比较函数
    auto last = std::unique(vec.begin(), vec.end(), customCompare);

    // 删除多余的元素
    vec.erase(last, vec.end());

    // 输出结果
    for(int i : vec) {
        std::cout << i << " ";
    }
    std::cout << std::endl;

    return 0;
}

---

微语录：不积跬步，无以至千里；不积小流，无以成江海。