课堂笔记| 第九章：容器和迭代器

已于 2022-11-11 16:59:48 修改
阅读量484 收藏
点赞数 1
分类专栏： C++ 文章标签： 算法 学习 c++ visual studio code
于 2022-11-11 16:59:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_64140451/article/details/127807587
版权

本节课要点：

  • 容器
  • 迭代器

一、容器

1. 基本概念 

容器：能够存储（任意类型）对象的类（模板）称为容器。

容器是一个很纯粹的概念，它的设计目的主要是为了存储对象，对象的类型对它来说并不重要。因此，容器一般被设计成为类模板。

2. 遍历操作 

我们之前为双向链表类编写的遍历函数：

void traverse(callback f) {
    for (auto p = head.next; p != &tail; p = p->next)
        f(p->data);
}

回调函数的类型受限，因此我们使用模板进行优化：

template <typename callback>
void traverse(callback&& f) {
    for (auto p = head.next; p != &tail; p = p->next)
        f(p->data);
}

如果还有其它参数，我们可以优化为：

template <typename callback, typename ...types>
void traverse(callback&& f, types&& ...args) {
    for (auto p = head.next; p != &tail; p = p->next)
        f(p->data);
}

为了实现完美转发，我们使用 types&&，避免类型折叠。

虽然带回调函数的遍历能够较灵活地访问容器元素，但是还是不够好。

二、数组的迭代器

容器的遍历操作往往与循环/迭代（iteration）关联。

这里我们以原生数组的遍历为例来说明迭代的一般性过程。

1. 迭代的特点

① 迭代是一个循环结构。

② 迭代的关键是设施是指针。

③ 迭代有起点，起点标记称为首迭代器。

④ 迭代有终点，终点标记称为哨兵迭代器。

⑤ 指针推进，使用 ++ 运算符完成。

⑥ 元素选取，使用 * 运算符完成。

⑦ 成员选择，使用 -> 运算符完成。

2. 数组的迭代器

//array.h
#pragma once

#include <iostream>
#include <exception>
#include <initializer_list>
#include <cassert>

template <typename value_t, size_t capacity>
class array {

public:
    using value_type = value_t;
    using pointer = value_type*;
    using reference = value_type&;

    value_type arr[capacity];

    void _copy(const array& a) {
        for (size_t i = 0; i < a.size(); ++i)
            arr[i] = a.arr[i];
    }

public:
    array() noexcept = default;

    array(const std::initializer_list<value_type> &l) noexcept {
        assert(l.size() <= capacity);
        
        size_t i = 0;
        for (auto &v : l)
            arr[i++] = v;
    }

    array(const array &a) noexcept {
        _copy(a);
    }

    array(array &&a) = delete;

    array &operator=(const array &a) {
        assert(capacity == a.size());
    
        _copy(a);
        return *this;
    }

    array &operator=(array &&a) = delete;

    ~array() noexcept {}

    reference at(size_t index) try {
        if (index >= capacity)
            throw std::out_of_range("out of range");

        return arr[index];     
    } catch (std::out_of_range& e) {
        std::cout << e.what() << std::endl;
        exit(1);
    }

    reference operator[](size_t index) {
        return this->at(index);
    }

    size_t size() const {
        return capacity;
    }

    using iterator = pointer;

    iterator begin() {
        return arr;
    }

    iterator end() {
        return arr + capacity;
    }

    using reverse_iterator = pointer;

    reverse_iterator rbegin() {
        return arr + capacity - 1;
    }

    reverse_iterator rend() {
        return arr - 1;
    }

    template <typename ...types>
    void emplace(iterator pos, types && ...args) {
        at(pos - arr) = value_type(args...);
    }
};

前面是我们已经完成的数组类内容，新增内容为：

using iterator = pointer;

iterator begin() {
    return arr;
}

iterator end() {
    return arr + capacity;
}

using reverse_iterator = pointer;

reverse_iterator rbegin() {
    return arr + capacity - 1;
}

reverse_iterator rend() {
    return arr - 1;
}

对于数组这种使用顺序存储模式的容器，原生指针就是其最简单、最使用的迭代器。因此，为这样的容器设计迭代器时，可以将其设计为原生指针的别名，我们称它为伪迭代器。

using iterator = pointer; //前向/正向迭代器

using reverse_iterator = pointer; //逆向迭代器

因为迭代器本身就是原生指针，所以无须为它重载必需的运算符函数。

设置首迭代器和哨兵迭代器：

iterator begin() {
    return arr;
}

iterator end() {
    return arr + capacity;
}

reverse_iterator rbegin() {
    return arr + capacity - 1;
}

reverse_iterator rend() {
    return arr - 1;
}

注意：哨兵是最后一个元素的下一个。 

只要类拥有了迭代器，就能进行基于范围的 for 循环：

#include <iostream>
#include "array.h"

int main() {
    array<int, 5> a{1, 2, 3, 4, 5};

    for (auto v : a)
        std::cout << v << ' ';
    std::cout << std::endl;

    return 0;
}

三、常规容器的迭代器 

对照迭代的特点，我们的迭代操作应该有如下特点： 

1. 使用迭代器的迭代的特点

① 迭代使用循环。

② 迭代器模拟原生指针，即是对原生指针的包装。

③ 设置首迭代器。

④ 设置哨兵迭代器。

⑤ 迭代器应具有的操作：

  • 复制迭代器，使用 = 运算符完成。
  • 比较迭代器，使用 != 运算符完成。
  • 推进迭代器，使用 ++ 运算符完成。
  • 返回迭代器所指元素，使用 * 运算符完成。
  • 返回迭代器内部指针，使用 -> 运算符完成。

⑥ 迭代器类是容器的内部类，且是一个依赖于容器类型参数的类模板。

⑦ 为了能使用包围模板的类型参数，应在迭代器类内部定义这些参数的别名。

⑧ 为了能高效地访问容器，迭代器类一般都是包围类的友元。

2. 双向链表的迭代器  

#pragma once

#include <iostream>
#include <exception>
#include <initializer_list>

#include "container.h"

template <typename value_t>
class dlist : public container<value_t> {
public:
    using value_type = typename container<value_t>::value_type;
    using pointer = typename container<value_t>::pointer;
    using reference = typename container<value_t>::reference;
    using difference_type = ptrdiff_t; //两个指针的差值，这是一个标准类型

    ...

    friend class iterator;
    class iterator {
    public:
        using value_type = dlist::value_type;
        using reference = dlist::reference;
        using difference_type = dlist::difference_type;

    private:
        nodeptr_t p;
        dlist * cp;

    public:
        iterator(nodeptr_t t = nullptr, dlist * c = nullptr) : p(t), cp(c) {}

        bool operator!=(const iterator& iter) {
            return p != iter.p;
        }

        iterator& operator++() {
            p = p->next;
            return *this;
        }

        reference operator*() {
            return p->data;
        }

        auto operator->() {
            return p;
        }
    };

    auto begin() {
        return iterator(head.next, this);
    }

    auto end() {
        return iterator(&tail, this);
    }
};

可见，我们设置了一个迭代器类，它是双向链表类的友元：

friend class iterator;

为了能使用包围模板的类型参数，我们定义了这些参数的别名：

public:
    using value_type = dlist::value_type;
    using reference = dlist::reference;
    using difference_type = dlist::difference_type;

 p 是我们包装在迭代器类内的原生指针，cp 用于指向容器类对象：

private:
    nodeptr_t p;
    dlist * cp;

迭代器应具有的操作：

bool operator!=(const iterator& iter) {
    return p != iter.p;
}

iterator& operator++() {
    p = p->next;
    return *this;
}

reference operator*() {
    return p->data;
}

auto operator->() {
    return p;
}

关于 * 运算符的重载：

考虑 * 的原始语义，*p 得到的是一个左值。如果返回值类型采用 auto，我们将得到一个右值。因此，我们需要返回的是一个引用，即 auto&。为了更便于理解，我们换成 reference。 

设置首迭代器和哨兵迭代器：

auto begin() {
    return iterator(head.next, this);
}

auto end() {
    return iterator(&tail, this);
}

- 逆向迭代器 

friend class reverse_iterator;
class reverse_iterator {
public:
    using value_type = dlist::value_type;
    using reference = dlist::reference;
    using difference_type = dlist::difference_type;

private:
    nodeptr_t p;
    dlist * cp;

public:
    reverse_iterator(nodeptr_t t = nullptr, dlist * c = nullptr) : p(t), cp(c) {}

    bool operator!=(const reverse_iterator& iter) {
        return p != iter.p;
    }

    reverse_iterator& operator++() {
        p = p->prior;
        return *this;
    }

    reference operator*() {
        return p->data;
    }
};

auto rbegin() {
    return reverse_iterator(tail.prior, this);
}

auto rend() {
    return reverse_iterator(&head, this);
}

- 随机存取迭代器 

重载 + 运算符，我们假设 d 是一个正数： 

iterator operator+(difference_type d) {
    iterator iter(*this);
    for (difference_type i = 0; i < d; ++i)
        iter.p = iter.p->next;

    return iter;
}

difference_type 是我们在前面定义的别名，用于表示两个指针之间的距离。其中，ptrdiff_t 是一个标准类型。

using difference_type = ptrdiff_t;

- 利用迭代器实现元素插入 

template <typename ...types>
void emplace(iterator pos, types&& ...args) try {
    if (pos != iterator()) {
        auto p = nodeptr_t(pos)->prior;
        _push(p, new node(p->next, p, args...))
    } else
        throw std::out_of_range("insert position out of range");
} catch (std::out_of_range &e) {
    std::cout << e.what() << std::endl;
    exit(1);
}

迭代器类构造函数的默认参数均设置为 nullptr，可以直接用于判断迭代器是否访问越界：

if (pos != iterator())

nodeptr_t 是重载的类型转换运算符，用于析取迭代器类内部的原生指针：

operator nodeptr_t() {
    return p;
}
狂放不羁霸
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
容器的迭代器
下酒番陪绅士的博客
02-14 317
容器的迭代器类型，容器的迭代器失效问题分析以及如何实现迭代器失效的原理讲解以及代码实现
【C++ STL学习】容器迭代器 iterator详解
Mr_zhuo_的博客
04-22 1990
目录 1. 本质 2. 分类 3. 操作 4. 各容器的迭代器 1. 本质 要访问顺序容器和关联容器中的元素，需要通过“迭代器（iterator）”进行。迭代器是一个变量，相当于容器和操纵容器的算法之间的中介。迭代器可以指向容器中的某个元素，通过迭代器就可以读写它指向的元素。从这一点上看，迭代器和指针类似。 2. 分类 1) 正向迭代器，定义方法如下： 容器类名::iterator 迭代器名; 2) 常量正向迭代器，定义方法如下： 容器类名::const_iterator...
C++迭代器和容器
weixin_51182789的博客
11-03 711
容器和迭代器 目录 容器和迭代器 1 前言说明： 1 迭代器 1 迭代器的介绍 1 迭代器的使用 1 前言说明： 最近更新时间：2022年11月3日19:23:31 作者：黎雪途 迭代器 迭代器的介绍 指针可以遍历存储空间的数据结构，但对于存储空间连续的，需要找一个类十余指针的类，来对非数组的数据结构进行遍历 定义：迭代器是一种检查容器元素并遍历的数据类型 迭代器提供对一个容器中的对象的访问方法，并定义了容器中对象的范围 迭代器是指针的泛化，它允许程序员用相同方式处理不同的数据结构 1. 迭代器类似于C
Python的容器、可迭代对象、迭代器、生成器
qq_38380338的博客
09-23 745
python迭代器与生成器
Iterater迭代器在常见容器中的使用
qq_52400091的博客
04-12 175
遍历List方法一：普通for循环i ++) {//list为集合的对象名 String temp =(String) list . get(i);遍历List方法二：增强for循环(使用泛型！遍历List方法三：使用Iterator迭代器(1)) {遍历List方法四：使用Iterator迭代器(2)//如果要遍历时，删除集合中的元素，建议使用这种方式！遍历Set方法一：增强for循环遍历Set方法二：使用Iterator迭代器) {
电力系统稳态分析：第6章 课堂测试.ppt
05-18
电力系统稳态分析：第6章 课堂测试.ppt
电力系统稳态分析：第5章 课堂测试.ppt
05-18
电力系统稳态分析：第5章 课堂测试.ppt
电力系统稳态分析：第3章 课堂测试.ppt
05-18
电力系统稳态分析：第3章 课堂测试.ppt
css课堂笔记前端css课堂笔记
08-05
CSS课堂笔记 本文档详细介绍了CSS的基本概念、语法、选择器、导入方式等知识点，为读者提供了系统的CSS基础知识。 一、CSS概念 CSS（Cascading Style Sheets）是一种用来表现HTML或XML等文件样式的计算机语言。...
跟李彦恢学javascript 电子书和课堂笔记1-15章.rar
03-28
跟李彦恢学javascript 电子书和课堂笔记1-15章 基础部分所有的课堂电子书，还有视频教程中的现场笔记code， 看完视频， 按照笔记自己动手做一遍，学习更牢固，更扎实。
【跟学C++】C++STL三大主要组件——容器/迭代器/算法(Study19)
cqy阳的博客
12-14 753
【跟学C++】C++STL三大主要组件——容器/迭代器/算法(Study19)
STL标准模板库 vector容器与迭代器入门
最新发布
Jcrry的博客
04-22 906
C++运算符重载，它可以让你的返回值不是一个指针而是一个特殊的类(迭代器) ++运算符的内部其实不是给指针++反而是把它的结点指针指向结点的next。如果是自定义类，则会调用元素的默认构造函数（例如：数字类型初始化为0 ，string会初始化为空字符串，指针类型会初始化为nullptr）容器的功能就是存储数据 迭代器的功能就是指向数据，并且可以实现前后移动（指针）算法和容器的接口的存在。C++里面的区间都是前面的是包含的后面是不包含的 [beg,end)第一个指针是指向堆上的地址（起始地址）
C++程序设计之STL模板（常用容器及迭代器）
qq_43328751的博客
09-22 431
参考：《ACM程序设计》——曾宗根 STL模板 1. vector向量容器 vector向量容器可以像数组一样对元素进行随机访问，还能在尾部插入元素，是一种简单高效的容器，用来代替数组 vector具有内存自动管理的功能，对于元素的插入和删除，可以动态调整所占的内存空间 vector容器有两个重要的方法，begin(),end() begin()返回的识首元素位置的迭代器，end()返回的是最后一个元素的下一个元素位置的迭代器。 创建vector对象 常用以下三种方式： (1)不指定容器的元素个...
C++中容器迭代器的基本使用方法3-3
hou09tian的博客
02-16 2130
1 迭代器与整形的加减运算 C++中的容器迭代器加上或者减去一个整型值，仍然是一个迭代器。这个新的迭代器相对原来的迭代器向前或者向后移动了若干个位置。如果是加上一个整型值，则迭代器会向前移动，减去一个整型值，则迭代器会向后移动，该整型值即为移动的位置。 如下代码为迭代器与整形加减运算的基本使用方法。 vector<int> v1 = { 0,1,2,3,4,5 }; vector<int>::iteratorit_begin = v1.begin(); vector<.
STL 常见容器及其对应的迭代器
weixin_42388331的博客
05-10 507
C++ primer 薄片系列之 STL 容器和迭代器
jxhaha的博客
10-31 265
容器的比较vector：元素保存在连续空间中。可变大小数组，支持快速随机访问，在尾部之外的位置插入或删除可能很慢 list：双向列表，只支持顺序访问。在任何位置插入或删除都很快 forward_list：单项列表，只支持单向顺序访问。在链表任何位置插入或者删除都很快 deque：双端队列，支持快速随机访问，在头尾插入，删除很快 string ：元素保存在连续空间中。和vect
C++ 容器与迭代器
qthello
05-14 559
C++ 中容器被定义为，数据存储上，有一种对象类型，它可以持有其它对象或指向其它对像的指针，这种对象类型就叫做容器。很简单，容器就是保存其它对象的对象。 顺序容器 向量vector 是一个线性顺序结构。相当于数组，但其大小可以不预先指定，并且自动扩展。它可以像数组一样被操作，由于它的特性我们完全可以将vector 看作动态数组。 在创建一个vector ...
STL的容器类和迭代器
weixin_44705391的博客
05-19 313
1.STL的容器类介绍 1.1、何为容器 (1)顾名思义，容器就是盛放东西的东西，这里被盛放的一般是数据对象，用来盛放的是容器类 (2)计算机中一切皆是数据，数据存储只能在内存中，而容器类是用做容器的内存的管理方法 (3)容器类的内核就是：数据结构 + 算法 (4)C语言语法内置的数组和结构体，就是语言源生支持的容器 (5)C++容器通过类库方式提供，容器类库被模板技术泛化后，就是STL容器了 1.2、STL有哪些容器类 (1)序列容器。元素在容器中的位置同元素的值无关，即容器不是排序的（类似于C数组）。包
有关C++模版
new_abc的专栏
12-17 947
前面看老罗文章时看到里面有很多的模版，不是很了解，这里做个笔记typedef  类型 定义名;类型说明只定义了一个数据类型的新名字而不是定义一种新的数据类型。定义名表示这个类型的新名字。例如: 用下面语句定义整型数的新名字:typedef int SIGNED_INT;typedef函数指针用法typedef  返回类型(*新类型)(参数表)typedef char (*PTRFUN)(int);
Flash制作课堂笔记.docx
10-13
Flash制作课堂笔记

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值