面试题：C++ STL 迭代器 end 范围扩展与自定义容器

设计 MyContainer 的迭代器：
- 自定义迭代器需要满足 STL 迭代器的要求，至少是双向迭代器（因为 std::find 等算法可能需要双向移动）。
- 迭代器类应该包含指向 MyType 对象的指针或引用作为内部状态，以及一些辅助方法来实现迭代器的行为。
- 定义 operator++、operator--、operator*、operator->、operator== 和 operator!= 等运算符。
- 例如：

class MyContainer;
class MyIterator {
    MyType* ptr;
    // 假设 MyContainer 类有一个获取数据指针的方法
    MyContainer* container; 
public:
    MyIterator(MyType* p, MyContainer* c) : ptr(p), container(c) {}
    MyIterator& operator++() {
        ++ptr;
        return *this;
    }
    MyIterator operator++(int) {
        MyIterator temp = *this;
        ++ptr;
        return temp;
    }
    MyIterator& operator--() {
        --ptr;
        return *this;
    }
    MyIterator operator--(int) {
        MyIterator temp = *this;
        --ptr;
        return temp;
    }
    MyType& operator*() {
        return *ptr;
    }
    MyType* operator->() {
        return ptr;
    }
    bool operator==(const MyIterator& other) const {
        return ptr == other.ptr;
    }
    bool operator!=(const MyIterator& other) const {
        return ptr != other.ptr;
    }
};

实现 end 迭代器的迭代范围扩展：
- 对于 end 迭代器，我们可以通过重载相关的比较运算符来实现特殊的查找逻辑。
- 例如，为了查找距离目标元素最近的前一个元素，当 std::find 到达 end 迭代器时，我们可以在 operator!= 中实现特殊逻辑。
- 在 MyContainer 类中，提供一个 find_closest_previous 方法，该方法接收目标元素，并在容器内查找最近的前一个元素。
- 关键代码如下：

class MyContainer {
    MyType* data;
    size_t size_;
public:
    MyContainer(size_t s) : size_(s) {
        data = new MyType[s];
    }
    ~MyContainer() {
        delete[] data;
    }
    MyIterator begin() {
        return MyIterator(data, this);
    }
    MyIterator end() {
        return MyIterator(data + size_, this);
    }
    MyType* find_closest_previous(const MyType& target) {
        MyType* closest = nullptr;
        for (size_t i = 0; i < size_; ++i) {
            if (data[i] < target) {
                if (!closest || data[i] > *closest) {
                    closest = &data[i];
                }
            }
        }
        return closest;
    }
};
// 重载 end 迭代器的 operator!= 以实现特殊查找逻辑
bool operator!=(const MyIterator& it, const MyIterator& end_it) {
    if (end_it.ptr == it.container->data + it.container->size_) {
        // 这里是特殊逻辑，当 it 到达通常的 end 位置时，进行特殊查找
        MyType* closest = it.container->find_closest_previous(*it.ptr);
        return closest != nullptr && closest != it.ptr;
    }
    return it.ptr != end_it.ptr;
}

使用示例：

int main() {
    MyContainer cont(5);
    // 假设 MyType 有合适的构造函数和比较运算符
    cont[0] = MyType(1);
    cont[1] = MyType(3);
    cont[2] = MyType(5);
    cont[3] = MyType(7);
    cont[4] = MyType(9);
    MyType target(6);
    auto it = std::find(cont.begin(), cont.end(), target);
    if (it != cont.end()) {
        // 正常找到元素
    } else {
        // 处理未找到元素，使用特殊逻辑找到最近的前一个元素
        MyType* closest = cont.find_closest_previous(target);
    }
    return 0;
}

星途面试题库

面试题：C++ STL 迭代器 end 范围扩展与自定义容器

知识考点

面试题答案