C++中STL提供的库函数解析（从宏观框架入手）

已于 2024-05-29 14:45:54 修改
阅读量900 收藏 24
点赞数 17
分类专栏： C++语言 文章标签： c++ java rpc
于 2024-05-29 14:13:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wanghao312/article/details/139293362
版权

我的目录

1. vector 是一种动态数组容器

在 C++ 中，vector 是一种动态数组容器，它提供了对元素的快速随机访问，并在需要时可以自动调整大小。下面是一个简化的 vector 容器的抽象代码结构，以帮助您从宏观上理解它的整体框架：

template <typename T>
class vector {
private:
    T* data;             // 存储元素的指针
    size_t size;         // 容器中元素的个数
    size_t capacity;     // 容器当前容量
public:
    vector() : data(nullptr), size(0), capacity(0) {}
    ~vector();
    // 迭代器相关
    class iterator {
        // 迭代器的实现细节
    public:
        // 迭代器的构造函数、析构函数等
        iterator() {}
        // 迭代器的操作符重载，如 ++, --, *, -> 等
    };
    iterator begin();
    iterator end();
    iterator cbegin() const;
    iterator cend() const;
    // 容量相关
    bool empty() const;
    size_t size() const;
    size_t max_size() const;
    void reserve(size_t new_cap);
    size_t capacity() const;
    void shrink_to_fit();
    // 元素访问
    T& operator[](size_t index);
    const T& operator[](size_t index) const;
    T& at(size_t index);
    const T& at(size_t index) const;
    T& front();
    const T& front() const;
    T& back();
    const T& back() const;
    // 修改操作
    void push_back(const T& value);
    void pop_back();
    iterator insert(iterator position, const T& value);
    iterator erase(iterator position);
    void clear();
    void resize(size_t n);
    void resize(size_t n, const T& value);
    // 其他操作
    void swap(vector& other);
};

这个抽象结构展示了 vector 容器的主要组成部分：

  • 模板参数： vector 是一个模板类，它可以存储任何类型的对象。
  • 私有成员： data 指针用于存储数组元素，size 表示当前元素的数量，capacity 表示当前容量。
  • 构造函数和析构函数： 用于创建和销毁向量。
  • 迭代器： 提供了向量的迭代器类，支持对向量进行遍历。
  • 容量相关函数： 检查向量是否为空、获取向量大小、最大容量、预留空间等。
  • 元素访问函数： 允许通过索引访问和修改向量中的元素。
  • 修改操作： 提供了在向量末尾添加或删除元素的操作，以及在向量中的任意位置插入或删除元素。
  • 其他操作： 如交换向量内容等。

请注意，这只是一个简化的抽象结构，实际的 vector 容器实现会更加复杂，包含更多的细节和优化。在 C++ 标准库中，vector 的实现在细节上可能会有所不同，以提供最高效的性能和符合标准的特性。

2. deque（双端队列）是一种可以同时从两端插入和删除元素的序列容器。

在 C++ 中，deque（双端队列）是一种可以同时从两端插入和删除元素的序列容器。它通常基于动态数组实现，提供了高效的随机访问和两端操作。下面是一个简化的 deque 容器的抽象代码结构，以帮助您从宏观上理解它的整体框架：

template <typename T, typename Allocator = std::allocator<T>>
class deque {
private:
    struct deque_node {
        T data;
        deque_node* next;
        deque_node* prev;
    };
    deque_node* front_node; // 指向队列前端的节点
    deque_node* rear_node; // 指向队列后端的节点
    size_t size;           // 队列中元素的个数
    Allocator alloc;       // 分配器对象，用于内存分配
public:
    deque() : front_node(nullptr), rear_node(nullptr), size(0), alloc() {}
    ~deque();
    // 迭代器相关
    class iterator {
        // 迭代器的实现细节
    public:
        // 迭代器的构造函数、析构函数等
        iterator() {}
        // 迭代器的操作符重载，如 ++, --, *, -> 等
    };
    iterator begin();
    iterator end();
    iterator cbegin() const;
    iterator cend() const;
    // 容量相关
    bool empty() const;
    size_t size() const;
    size_t max_size() const;
    // 元素访问
    T& front();
    const T& front() const;
    T& back();
    const T& back() const;
    // 修改操作
    void push_front(const T& value);
    void push_back(const T& value);
    void pop_front();
    void pop_back();
    iterator insert(iterator position, const T& value);
    iterator erase(iterator position);
    void clear();
    void resize(size_t n);
    void resize(size_t n, const T& value);
    // 其他操作
    void swap(deque& other);
};

这个抽象结构展示了 deque 容器的主要组成部分：

  • 模板参数： deque 是一个模板类，它可以存储任何类型的对象。它还有一个可选的模板参数，用于指定分配器类型，默认为 std::allocator<T>。
  • 私有成员： deque_node 结构体用于表示队列节点，包含值、前驱和后继指针。此外，还有指向头节点和尾节点的指针，以及表示队列大小的变量。
  • 构造函数和析构函数： 用于创建和销毁队列。
  • 迭代器： 提供了队列的迭代器类，支持对队列进行遍历。
  • 容量相关函数： 检查队列是否为空、获取队列大小、最大容量等。
  • 元素访问函数： 允许通过索引访问和修改队列中的元素。
  • 修改操作： 提供了在队列前端或后端添加或删除元素的操作，以及在队列中的任意位置插入或删除元素。
  • 其他操作： 如交换队列内容等。

请注意，这只是一个简化的抽象结构，实际的 deque 容器实现会更加复杂，包含更多的细节和优化。在 C++ 标准库中，deque 的实现在细节上可能会有所不同，以提供最高效的性能和符合标准的特性。

3. stack 是一种容器适配器，它提供了后进先出（LIFO）的数据结构。

在 C++ 中，stack 是一种容器适配器，它提供了后进先出（LIFO）的数据结构。stack 通常是基于其他容器（如 vector、deque 或 list）实现的，默认情况下是基于 deque。下面是一个简化的 stack 容器适配器的抽象代码结构，以帮助您从宏观上理解它的整体框架：

template <typename T, typename Container = std::deque<T>>
class stack {
protected:
    Container c; // 用于存储栈元素的底层容器
public:
    stack() : c() {} // 默认构造函数
    // 元素访问
    T& top(); // 返回栈顶元素的引用
    const T& top() const; // 返回栈顶元素的常量引用
    // 容量相关
    bool empty() const; // 检查栈是否为空
    size_t size() const; // 返回栈中元素的个数
    // 修改操作
    void push(const T& value); // 在栈顶插入元素
    void pop(); // 删除栈顶元素
    // 比较操作
    friend bool operator==(const stack& lhs, const stack& rhs);
    friend bool operator!=(const stack& lhs, const stack& rhs);
    friend bool operator<(const stack& lhs, const stack& rhs);
    friend bool operator<=(const stack& lhs, const stack& rhs);
    friend bool operator>(const stack& lhs, const stack& rhs);
    friend bool operator>=(const stack& lhs, const stack& rhs);
};

这个抽象结构展示了 stack 容器适配器的主要组成部分：

  • 模板参数： stack 是一个模板类，它可以存储任何类型的对象。它还有一个可选的模板参数，用于指定底层容器的类型，默认为 std::deque<T>。
  • 保护成员： c 是用于存储栈元素的底层容器。
  • 构造函数： 用于创建栈。
  • 元素访问函数： 允许访问栈顶元素。
  • 容量相关函数： 检查栈是否为空、获取栈中元素的个数。
  • 修改操作： 提供了在栈顶添加或删除元素的操作。
  • 比较操作： 提供了栈之间的比较操作。

请注意，这只是一个简化的抽象结构，实际的 stack 容器适配器实现会更加复杂，包含更多的细节和优化。在 C++ 标准库中，stack 的实现在细节上可能会有所不同，以提供符合标准的特性。

4. queue 是一种容器适配器，它提供了先进先出（FIFO）的数据结构。

在 C++ 中，queue 是一种容器适配器，它提供了先进先出（FIFO）的数据结构。queue 通常是基于其他容器（如 deque）实现的，默认情况下是基于 deque。下面是一个简化的 queue 容器适配器的抽象代码结构，以帮助您从宏观上理解它的整体框架：

template <typename T, typename Container = std::deque<T>>
class queue {
protected:
    Container c; // 用于存储队列元素的底层容器
public:
    queue() : c() {} // 默认构造函数
    // 元素访问
    T& front(); // 返回队列前端元素的引用
    const T& front() const; // 返回队列前端元素的常量引用
    T& back(); // 返回队列后端元素的引用
    const T& back() const; // 返回队列后端元素的常量引用
    // 容量相关
    bool empty() const; // 检查队列是否为空
    size_t size() const; // 返回队列中元素的个数
    // 修改操作
    void push(const T& value); // 在队列后端插入元素
    void pop(); // 删除队列前端元素
    // 比较操作
    friend bool operator==(const queue& lhs, const queue& rhs);
    friend bool operator!=(const queue& lhs, const queue& rhs);
    friend bool operator<(const queue& lhs, const queue& rhs);
    friend bool operator<=(const queue& lhs, const queue& rhs);
    friend bool operator>(const queue& lhs, const queue& rhs);
    friend bool operator>=(const queue& lhs, const queue& rhs);
};

这个抽象结构展示了 queue 容器适配器的主要组成部分：

  • 模板参数： queue 是一个模板类，它可以存储任何类型的对象。它还有一个可选的模板参数，用于指定底层容器的类型，默认为 std::deque<T>。
  • 保护成员： c 是用于存储队列元素的底层容器。
  • 构造函数： 用于创建队列。
  • 元素访问函数： 允许访问队列的前端和后端元素。
  • 容量相关函数： 检查队列是否为空、获取队列中元素的个数。
  • 修改操作： 提供了在队列后端添加元素和删除队列前端元素的操作。
  • 比较操作： 提供了队列之间的比较操作。

请注意，这只是一个简化的抽象结构，实际的 queue 容器适配器实现会更加复杂，包含更多的细节和优化。在 C++ 标准库中，queue 的实现在细节上可能会有所不同，以提供符合标准的特性。

5. list 是一种双向链表容器，它提供对元素的快速插入和删除。

在 C++ 中，list 是一种双向链表容器，它提供对元素的快速插入和删除。STL 中的 list 容器通常是基于模板实现的，这意味着它可以存储任何类型的对象。下面是一个简化的 list 容器的抽象代码结构，以帮助您从宏观上理解它的整体框架：

template <typename T>
class list {
private:
    struct ListNode {
        T value;
        ListNode* next;
        ListNode* prev;
        
        ListNode(const T& val) : value(val), next(nullptr), prev(nullptr) {}
    };
    ListNode* head;
    ListNode* tail;
    size_t size;
public:
    list() : head(nullptr), tail(nullptr), size(0) {}
    ~list();
    // 迭代器相关
    class iterator {
        // 迭代器的实现细节
    public:
        // 迭代器的构造函数、析构函数等
        iterator() {}
        // 迭代器的操作符重载，如 ++, --, *, -> 等
    };
    iterator begin();
    iterator end();
    iterator rbegin();
    iterator rend();
    // 容量相关
    bool empty() const;
    size_t size() const;
    size_t max_size() const;
    // 元素访问
    T& front();
    const T& front() const;
    T& back();
    const T& back() const;
    // 修改操作
    void push_front(const T& value);
    void pop_front();
    void push_back(const T& value);
    void pop_back();
    void insert(iterator position, const T& value);
    void erase(iterator position);
    void clear();
    void resize(size_t n);
    void resize(size_t n, const T& value);
    // 其他操作
    void swap(list& other);
    void merge(list& other);
    void splice(iterator position, list& other, iterator it);
    void remove(const T& value);
    void unique();
    void reverse();
};

这个抽象结构展示了 list 容器的主要组成部分：

  • 模板参数： list 是一个模板类，它可以存储任何类型的对象。
  • 私有成员： 内部 ListNode 结构体用于表示链表节点，包含值、前驱和后继指针。此外，还有指向头节点、尾节点的指针和表示链表大小的变量。
  • 构造函数和析构函数： 用于创建和销毁链表。
  • 迭代器： 提供了链表的迭代器类，支持对链表进行遍历。
  • 容量相关函数： 检查链表是否为空、获取链表大小等。
  • 元素访问函数： 允许访问链表的第一个和最后一个元素。
  • 修改操作： 提供了在链表前端或后端添加或删除元素的操作，以及在链表中的任意位置插入或删除元素。
  • 其他操作： 如交换链表内容、合并链表、分割链表等。

请注意，这只是一个简化的抽象结构，实际的 list 容器实现会更加复杂，包含更多的细节和优化。在 C++ 标准库中，list 的实现在细节上可能会有所不同，以提供最高效的性能和符合标准的特性。

6. set 是一种基于红黑树实现的集合容器，它提供了对唯一元素的快速查找、插入和删除操作。

在 C++ 中，set 是一种基于红黑树实现的集合容器，它提供了对唯一元素的快速查找、插入和删除操作。set 容器通常基于模板实现，以支持存储不同类型的元素。下面是一个简化的 set 容器的抽象代码结构，以帮助您从宏观上理解它的整体框架：

template <typename T, typename Compare = std::less<T>, typename Allocator = std::allocator<T>>
class set {
private:
    struct set_node {
        T value;
        set_node* left;
        set_node* right;
        set_node* parent;
        bool red;
        
        set_node(const T& val) : value(val), left(nullptr), right(nullptr), parent(nullptr), red(true) {}
    };
    set_node* root;
    Compare comp;
    Allocator alloc;
    size_t size;
public:
    set() : root(nullptr), comp(), alloc(), size(0) {}
    ~set();
    // 容量相关
    size_t size() const;
    size_t max_size() const;
    // 修改操作
    void insert(const T& value);
    void emplace(T&& value);
    iterator find(const T& value);
    bool erase(const T& value);
    void clear();
    // 比较操作
    bool empty() const;
    friend bool operator==(const set& lhs, const set& rhs);
    friend bool operator!=(const set& lhs, const set& rhs);
    friend bool operator<(const set& lhs, const set& rhs);
    friend bool operator<=(const set& lhs, const set& rhs);
    friend bool operator>(const set& lhs, const set& rhs);
    friend bool operator>=(const set& lhs, const set& rhs);
    // 迭代器相关
    class iterator {
        // 迭代器的实现细节
    public:
        // 迭代器的构造函数、析构函数等
        iterator() {}
        // 迭代器的操作符重载，如 ++, --, *, -> 等
    };
    iterator begin();
    iterator end();
    iterator cbegin() const;
    iterator cend() const;
    // 输出操作符
    friend std::ostream& operator<<(std::ostream& os, const set& s);
};

这个抽象结构展示了 set 容器的主要组成部分：

  • 模板参数： set 是一个模板类，它可以存储任何类型的对象。它还有两个可选的模板参数，用于指定比较函数和分配器类型，默认为 std::less<T> 和 std::allocator<T>。
  • 私有成员： set_node 结构体用于表示红黑树节点，包含值、左右子节点、父节点和颜色标志。此外，还有指向根节点的指针，以及表示集合大小的变量。
  • 构造函数和析构函数： 用于创建和销毁集合。
  • 容量相关函数： 检查集合是否为空、获取集合大小、最大容量等。
  • 修改操作： 提供了在集合中插入、查找和删除元素的操作。
  • 比较操作： 提供了集合之间的比较操作。
  • 迭代器相关： 提供了集合的迭代器类，支持对集合进行遍历。
  • 输出操作符： 提供了输出集合内容到标准输出流的功能。

请注意，这只是一个简化的抽象结构，实际的 set 容器实现会更加复杂，包含更多的细节和优化。在 C++ 标准库中，set 的实现在细节上可能会有所不同，以提供最高效的性能和符合标准的特性。

7. map 是一种基于红黑树实现的关联容器，它提供了对键值对的无序（但有序）存储。

在 C++ 中，map 是一种基于红黑树实现的关联容器，它提供了对键值对的无序（但有序）存储。map 容器通常基于模板实现，以支持存储不同类型的键和值。下面是一个简化的 map 容器的抽象代码结构，以帮助您从宏观上理解它的整体框架：

template <typename Key, typename T, typename Compare = std::less<Key>, typename Allocator = std::allocator<std::pair<const Key, T>>>
class map {
private:
    struct map_node {
        Key key;
        T value;
        map_node* left;
        map_node* right;
        map_node* parent;
        bool red;
        
        map_node(const Key& k, const T& v) : key(k), value(v), left(nullptr), right(nullptr), parent(nullptr), red(true) {}
    };
    map_node* root;
    Compare comp;
    Allocator alloc;
    size_t size;
public:
    map() : root(nullptr), comp(), alloc(), size(0) {}
    ~map();
    // 容量相关
    size_t size() const;
    size_t max_size() const;
    // 修改操作
    std::pair<iterator, bool> insert(const std::pair<const Key, T>& value);
    std::pair<iterator, bool> insert(std::pair<const Key, T>&& value);
    iterator find(const Key& key);
    T& at(const Key& key);
    const T& at(const Key& key) const;
    iterator erase(const Key& key);
    void clear();
    // 比较操作
    bool empty() const;
    friend bool operator==(const map& lhs, const map& rhs);
    friend bool operator!=(const map& lhs, const map& rhs);
    friend bool operator<(const map& lhs, const map& rhs);
    friend bool operator<=(const map& lhs, const map& rhs);
    friend bool operator>(const map& lhs, const map& rhs);
    friend bool operator>=(const map& lhs, const map& rhs);
    // 迭代器相关
    class iterator {
        // 迭代器的实现细节
    public:
        // 迭代器的构造函数、析构函数等
        iterator() {}
        // 迭代器的操作符重载，如 ++, --, *, -> 等
    };
    iterator begin();
    iterator end();
    iterator cbegin() const;
    iterator cend() const;
    // 输出操作符
    friend std::ostream& operator<<(std::ostream& os, const map& m);
};

这个抽象结构展示了 map 容器的主要组成部分：

  • 模板参数： map 是一个模板类，它可以存储任何类型的键和值。它还有两个可选的模板参数，用于指定比较函数和分配器类型，默认为 std::less<Key> 和 std::allocator<std::pair<const Key, T>>。
  • 私有成员： map_node 结构体用于表示红黑树节点，包含键、值、左右子节点、父节点和颜色标志。此外，还有指向根节点的指针，以及表示集合大小的变量。
  • 构造函数和析构函数： 用于创建和销毁映射。
  • 容量相关函数： 检查映射是否为空、获取映射大小、最大容量等。
  • 修改操作： 提供了在映射中插入、查找和删除键值对的操作。
  • 比较操作： 提供了映射之间的比较操作。
  • 迭代器相关： 提供了映射的迭代器类，支持对映射进行遍历。
  • 输出操作符： 提供了输出映射内容到标准输出流的功能。

请注意，这只是一个简化的抽象结构，实际的 map 容器实现会更加复杂，包含更多的细节和优化。在 C++ 标准库中，map 的实现在细节上可能会有所不同，以提供最高效的性能和符合标准的特性。

8. 补充内容 string类

在 C++ 中，string 是一种字符串容器，它提供了对字符串的灵活操作。string 容器是基于 C++ 的字符数组（char[]）实现的，并提供了额外的功能，如字符串拼接、查找、替换等。下面是一个简化的 string 容器的抽象代码结构，以帮助您从宏观上理解它的整体框架：

#include <cstring> // 用于 strlen 和 memcpy
template <typename CharT, typename Traits = std::char_traits<CharT>, typename Allocator = std::allocator<CharT>>
class basic_string {
private:
    // 字符数组，用于存储字符串内容
    CharT* data;
    // 字符数组的大小
    size_t size;
    // 字符数组的长度（以字符为单位）
    size_t length;
    // 分配器对象，用于内存分配
    Allocator alloc;
public:
    basic_string() : data(nullptr), size(0), length(0), alloc() {}
    ~basic_string();
    // 容量相关
    size_t capacity() const;
    void reserve(size_t new_capacity);
    void shrink_to_fit();
    // 元素访问
    CharT& operator[](size_t index);
    const CharT& operator[](size_t index) const;
    CharT& at(size_t index);
    const CharT& at(size_t index) const;
    CharT* data() { return data; }
    const CharT* data() const { return data; }
    size_t size() const { return size; }
    size_t length() const { return length; }
    // 修改操作
    void clear();
    void push_back(CharT c);
    void pop_back();
    void insert(size_t index, const CharT* str, size_t count);
    void insert(size_t index, size_t count, CharT c);
    void erase(size_t index, size_t count);
    void resize(size_t new_size);
    void resize(size_t new_size, CharT c);
    // 比较操作
    bool empty() const;
    bool operator==(const basic_string& other) const;
    bool operator!=(const basic_string& other) const;
    bool operator<(const basic_string& other) const;
    bool operator<=(const basic_string& other) const;
    bool operator>(const basic_string& other) const;
    bool operator>=(const basic_string& other) const;
    // 字符串操作
    void swap(basic_string& other);
    void assign(const CharT* str, size_t count);
    void assign(size_t count, CharT c);
    void append(const CharT* str, size_t count);
    void append(size_t count, CharT c);
    void replace(size_t index, size_t count, const CharT* str, size_t count2);
    void replace(size_t index, size_t count, size_t count2, CharT c);
    void replace(size_t index, size_t count, const basic_string& str);
    void replace(size_t index, size_t count, const basic_string& str, size_t count2);
    void remove(size_t index, size_t count);
    void remove(size_t index, size_t count, CharT c);
    void remove(size_t index, size_t count, const basic_string& str);
    void remove(size_t index, size_t count, const basic_string& str, size_t count2);
    void remove(size_t index, size_t count, const CharT* str, size_t count2);
    // 查找和替换
    size_t find(const basic_string& str, size_t pos = 0) const;
    size_t find(const CharT* str, size_t pos = 0) const;
    size_t find(const CharT* str, size_t pos, size_t count) const;
    size_t find(const CharT& c, size_t pos = 0) const;
    size_t rfind(const basic_string& str, size_t pos = npos) const;
    size_t rfind(const CharT* str, size_t pos = npos) const;
    size_t rfind(const CharT* str, size_t pos, size_t count) const;
    size_t rfind(CharT c, size_t pos = npos) const;
    size_t find_first_of(const basic_string& str, size_t pos = 0) const;
    size_t find_first_of(const CharT* str, size_t pos = 0) const;
    size_t find_first_of(const CharT* str, size_t pos, size_t count) const;
    size_t find_first_of(CharT c, size_t pos = 0) const;
    size_t find_first_not_of(const basic_string& str, size_t pos = 0) const;
    size_t find_first_not_of(const CharT* str, size_t pos = 0) const;
    size_t find_first_not_of(const CharT* str, size_t pos, size_t count) const;
    size_t find_first_not_of(CharT c, size_t pos = 0) const;
    size_t find_last_of(const basic_string& str, size_t pos = npos) const;
    size_t find_last_of(const CharT* str, size_t pos = npos) const;
    size_t find_last_of(const CharT* str, size_t pos, size_t count) const;
    size_t find_last_of(CharT c, size_t pos = npos) const;
    size_t find_last_not_of(const basic_string& str, size_t pos = npos) const;
    size_t find_last_not_of(const CharT* str, size_t pos = npos) const;
    size_t find_last_not_of(const CharT* str, size_t pos, size_t count) const;
    size_t find_last_not_of(CharT c, size_t pos = npos) const;
    // 子串操作
    basic_string substr(size_t pos = 0, size_t count = npos) const;
    // 转换操作
    basic_string& operator+=(const basic_string& str);
    basic_string& operator+=(const CharT* str);
    basic_string& operator+=(CharT c);
    basic_string operator+(const basic_string& str) const;
    basic_string operator+(const CharT* str) const;
    basic_string operator+(CharT c) const;
    // 输出操作符
    friend std::ostream& operator<<(std::ostream& os, const basic_string& str);
};

这个抽象结构展示了 string 容器的主要组成部分：

  • 模板参数： string 是一个模板类，它可以存储任何类型的字符。它还有一个可选的模板参数，用于指定字符类型，默认为 char。
  • 私有成员： data 指针用于存储字符串内容，size 表示字符数组的大小，length 表示字符串的长度，alloc 用于内存分配。
  • 构造函数和析构函数： 用于创建和销毁字符串。
  • 容量相关函数： 检查字符串是否为空、获取字符串大小、最大容量等。
  • 元素访问函数： 允许通过索引访问和修改字符串中的字符。
  • 修改操作： 提供了在字符串末尾添加或删除字符的操作，以及在字符串中的任意位置插入或删除字符。
  • 比较操作： 提供了字符串之间的比较操作。
  • 字符串操作： 如拼接、替换、查找等。
  • 输出操作符： 提供了输出字符串到标准输出流的功能。
    请注意，这只是一个简化的抽象结构，实际的 string 容器实现会更加复杂，包含更多的细节和优化。

9.迭代器和容器的对应关系

在 C++ STL 中，几乎所有的容器都支持迭代器，但是有一些容器适配器（adapters）本身不提供迭代器。这些适配器依赖于它们所适配的底层容器来实现操作，因此它们不提供自己的迭代器。以下是几种常见的 STL 容器和它们是否支持迭代器的说明：

  1. 迭代器支持的容器：
    • vector：支持随机访问迭代器。
    • deque：支持随机访问迭代器。
    • list：支持双向迭代器。
    • set 和 multiset：支持双向迭代器。
    • map 和 multimap：支持双向迭代器。
    • stack 和 queue：虽然不提供自己的迭代器，但它们可以适配底层支持迭代器的容器（如 deque），因此可以间接使用底层容器的迭代器。
  2. 不提供迭代器的容器适配器：
    • stack 和 queue：它们是容器适配器，不提供自己的迭代器。它们可以适配底层支持迭代器的容器，如 deque，但是它们本身不提供迭代器。
  3. 特殊容器：
    • string：支持随机访问迭代器。
    • array：没有迭代器，它只是一个普通的数组，可以使用指针进行遍历，指针可以实现的功能类似于随机访问迭代器。
  4. 其他容器：
    • bitset：提供一种特殊的迭代器，用于遍历位集。
    • forward_list：支持单向迭代器。

需要注意的是，即使某些容器适配器本身不提供迭代器，它们仍然可以通过适配底层容器来间接使用迭代器。例如，stack 和 queue 可以通过适配 deque 容器来使用 deque 的迭代器。
总的来说，几乎所有的 STL 容器都支持迭代器，但有些容器适配器本身不提供迭代器，而是依赖于底层容器。如果你需要使用迭代器来遍历或操作容器，你应该检查底层容器是否支持迭代器，并根据需要使用相应的迭代器。

九层指针
关注
专栏目录
C++ STL库函数学习
weixin_43234021的博客
09-20 593
C++ STL库学习一、模板1. 函数模板1.1 函数模板和普通函数的区别1.2 C++函数模板机制剖析1.3 函数模板案例—char、int类型数组排序2. 类模板2.1 类模板基本语法2.2 类模板案例—类模板派生普通类2.3 类模板案例—类模板派生类模板3. 普通类.h 与 .cpp分离编写方式 一、模板 1. 函数模板 #include <iostream> using namespace std; //模板技术：类型参数化，编写代码可以忽略类型 //为了让编译器区分普通函数 模板函
c++ STL与常用库函数
weixin_51008024的博客
11-22 601
c++ STL与常用库函数vector(变长数组)queue(队列)stack(栈)deque(双端队列)setmapinclude位运算常用方法常用库函数 vector(变长数组) 变长数组，支持随机访问，不支持在任意位置O(1)插入。为了保证效率，元素的增删一般应该在末尾进行 #include<vector> //头文件 vector<int> a; //相当于一个长度动态变化的int 数组 vector<int> b[233]; //相当于第一维长
C++的STL库常见函数
花火酱的抱枕
03-02 1227
vector容器 尾部添加，push_back() #include <iostream> #include <vector> using namespace std; int main(int argc, char *argv[]) { vector<int> v; int n; cout<<"输入最大值n:"<<endl; cin>>n; for(int i=0;i<n;i++) { v.push_bac
C++STL库函数
03-30
C++STL库的所有库函数，每个里面都有很详细的中文注释，适合想深入理解STL库函数的人下载学习。
[C++]——STL(标准模板库)
最新发布
weixin_50720782的博客
08-09 767
STL标准模板库
C++ STL 库函数大全
住在半山腰的螃蟹专栏
10-21 5588
#include 　　　　//设定插入点 #include 　　　　 //字符处理 #include 　　　　 //定义错误码 #include 　　　　 //浮点数处理 #include 　　　 //文件输入／输出 #include 　　　 //参数化输入／输出 #include 　　　//数据流输入／输出 #include 　　　　//定义各种数据类型最值常量 #include
C++中的STL库
L_xuansg的博客
06-29 1267
STL（Standard Template Library，标准模板库）是 C++ 中的一个重要部分，提供了丰富的通用模板类和函数模板，用于实现常见的数据结构和算法。它的设计目标是提供高效、灵活和可复用的程序组件，使得开发者可以更加专注于问题的解决而不是数据结构和算法的实现细节。
C++ STL库函数总结（纯手打，主要偏向ACM竞赛方面使用）
05-11
C++ STL库函数总结（纯手打，主要偏向ACM竞赛方面使用）
C++STL库常用库函数总结
07-08
C++ Standard Template Library (STL) 是C++编程语言中不可或缺的一部分，它提供了一系列高效、易用的数据结构和算法。以下是对C++ STL库中常用库函数的详细总结： 1. **vector** - `size()`：返回向量中元素的...
C++库函数及STL算法
09-24
在C++编程中，库函数和STL（Standard Template Library，标准模板库）是不可或缺的组成部分，它们极大地提升了代码的效率和可读性。本文将深入探讨C++库函数和STL算法，以及如何在实际编程中应用这些概念。 首先，...
C++中STL用法超详细总结
热门推荐
一只大笨猫的博客
08-21 20万+
目录 1 什么是STL？ 2 STL内容介绍 2.1 容器 2.2 STL迭代器 2.3 算法 2.4 仿函数 2.4.1 概述 2.4.2 仿函数(functor)在编程语言中的应用  2.4.3 仿函数在STL中的定义 2.5 容器适配器 2.5.1 stack 2.5.2 queue &amp; priority_queue 3 常用容器用法介绍  3.1 vec...
一些好用的c++ STL库函数
Boil的博客
07-28 1589
stl可以说是懒癌患者福利了 全排列函数next_permutation 今天在洛谷做题的时候发现一个题简直是这个函数的完美应用 题目链接：洛谷P1088 火星人 头文件：#include < algorithm > 时间复杂度 ：O(n) 函数原型： bool next_permutation(iterator start,iterator end) 该函数的作用是求全排...
C++常用STL及常用库函数
weixin_42638946的博客
02-21 1263
C++常用STL及常用库函数 vector #include <iostream> #include <vector> using namespace std; int main() { // 定义vector vector<int> a; // 定义一个空vector vector<int> b(3); // 定义一个长度为3，值全为0的vector vector<int> c({1, 2, 3}); /
C++ STL常用函数总结
fucheng的博客
01-09 1050
C++ STL常用用法总结
STL标准库函数总结
xx_ii
07-31 4758
参考链接 0 前言： 平时STL自己用的很少，很多库函数都不是很熟悉，趁着最近有空，将STL的知识学习一下。主要学习一下,pair,vector,set,vector,stack,queue,map,string. 1 pair 位于头文件&amp;amp;amp;amp;amp;amp;amp;amp;lt; iostream&amp;amp;amp;amp;amp;amp;amp;amp;gt;中用来表示一个二元组或元素对 2.1 使用pai
C++ STL使用
u012477435的博客
09-23 2143
文章目录C++ STL使用一、什么是STL二、STL内容介绍2.1 STL中六大组件2.2 容器2.3 迭代器2.4 算法2.4.1 算法分类2.5 仿函数2.5.1 仿函数(functor)在编程语言中的应用2.5.2 仿函数在STL中的定义2.6 容器适配器2.6.1 stack2.6.2 queue & priority_queue三、常用容器用法介绍3.1 vector3.1.1 基本函数实现3.1.2 基本用法3.1.3 实例3.2 deque3.2.1 声明deque容器3.2.2 de
​C++STL库函数总结​
欢迎访问方偲的博客
05-26 4271
转载自C++STL库函数总结 #include< algorithm >库函数 1.sort排序 2.reverse倒转 3.unique去重 4.二分查找 5.find函数查找 6.字符串和整型的互换 7.排列组合 #include< vector >库函数 1.vector介绍 2.vector的功能函数 #include< stack >堆栈库函数 1.stack
C++语言STL库常用函数
weixin_51474578的博客
04-07 2369
1、memset（）批量初始化函数 1.原型：void *memset（集合，初始内容，大小）。 2.初始化可以为两种内容：整型0和-1，字符ASCLL 3.应用场景： 初始化数组0和-1（只能这两个值）： #include<bits/stdc++.h> using namespace std; int main() { int a[10]; int b[10]; int c[10]; mem...
C++ STL库函数总结：集合(set)详解（ACM竞赛）
本文将对C++ STL库中集合(set)的相关函数进行总结，以便竞赛选手更好地掌握。 集合(set)是由节点组成的红黑树，每个节点都包含着一个元素，节点之间按照某种作用于元素对的谓词排列。集合中的元素不会重复，并默认...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

九层指针

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

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

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

打赏作者

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

抵扣说明：

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

余额充值