-1

我有一个任务让我发疯。我一直在研究基本概念以增加我的知识并尝试将其应用于这个问题，但我有点卡住了。

我们有一个 main.cpp 文件，用于测试具有以下语法的 VectorOfVectors 类：

for( int num : intVov )
{
     printf( "%d ", num );
}

我们正在创建自己的 VectorOfVectors 类，并将模板化向量作为项目。

我们必须通过创建我们自己的迭代所有值的自定义迭代器来使 main 函数正常工作，如 main 函数所示。我一直在研究基于范围的迭代器，但我对如何构建自己的迭代器有点困惑，而且因为它是向量的向量，所以语法与一些在线示例不太匹配。

我想获得有关如何创建此迭代器的指导。我知道我需要一个 begin() 和 end() 函数，并覆盖 operator++ 函数以使其工作。我的迭代器会使用 int 值作为我在 operator++ 中递增的指针吗？我需要两个指针吗？begin() 和 end() 会返回什么、迭代器、整数、T 值或向量？我应该如何构造迭代器以及我需要哪些数据？迭代器构造函数会将两个指针作为值，还是一个，或者它是如何工作的？迭代器是否需要它自己的 VectorOfVectors 副本来迭代（并在构造函数中设置）？

我将如何增加指针？任何帮助、一般知识甚至提示将不胜感激！

这是我一直在摆弄的东西，仅供参考。

#include <vector>

using std::vector;


template< typename T > class VectorOfVectors
{
public:

    class iterator
    {
        public:
            //Constructor
            iterator(const VectorOfVectors<T> * vov, int pos_vov, int pos_v)
            {
                _pos_vov = pos_vov;
                _pos_v = pos_v;
                _vov = vov;
            }

            bool operator!= (const iterator & other) const
            {
                return pos != other._pos;
            }

            int operator* () const;

            const iterator operator++ ()
            {
                _pos_v++;
                if (_pos_v == _pos_vov->end())
                {
                    _pos_vov++;
                    if (_pos_vov == _vov.end())
                    {
                        --_pos_vov;
                        _pos_v = _pos_vov->end();
                        --_pos_v;
                        return (*this);
                    }
                    else
                    {
                        _pos_v = _pos_vov->begin();
                        return (*this);
                    }
                }
                else
                {
                    return (*this);
                }
            }

    private:
        int _pos_v;
        int _pos_vov;
        const VectorOfVectors<T> * _vov;
    };

    void AddEmptyVector()
    {
        vectorOfVectors.push_back(new vector<T>());
    }

    int GetVectorCount() const
    {
        return vectorOfVectors.size();
    }

    vector<T> GetVectorAtIndex(int index)
    {
        return vectorOfVectors.at(index);
    }

    void AddCopyOfVector(vector<T> & toBeAdded)
    {
        vectorOfVectors.push_back(toBeAdded);
    }

    iterator begin() const
    {
        return iter(this, 0, 0);
    }

    iterator end() const
    {
        return iterator(this, 4, 3);
    }

private:
    vector< vector<T> > vectorOfVectors = new vector< vector<T> >();

};
4

1 回答 1

0

从for您发布的循环来看，教师似乎希望迭代器遍历向量向量的各个元素（而不是例如遍历子向量）。

begin()并且end()必须始终返回iterators，而不是 iterators 指向的元素（例如int，在这种情况下不是 raw s）。在某些特殊情况下，可能会生成这些原始指针（例如，我认为某些 STL 实现std::vector::iterator会这样做），但通常它们需要很小struct的 s 包含足够的信息来导航父数据结构。

有关语法实际转换为的内容，请参阅此页面。for (var : collection)这告诉您需要设计一个Iter具有以下属性的迭代器类型：

  • *Iter返回 aT或可转换为T（如T&）的东西。你目前有这个错误——你的int operator* () const;（似乎没有定义？）int由于某种原因正在返回一个。
  • ++Iter将迭代器移动到下一个元素。
  • Iter1 != Iter2false当两个迭代器指向同一个元素时返回。

如何实际创建Iter类型完全取决于您。在我看来，使用 2 个整数索引并检查++您当前正在执行的“环绕”似乎是合理的。

其他注意事项：

  • 您begin()当前的电话return iter(this, 0, 0);，甚至不会编译。
  • 请不要像在和std::vector的声明中那样动态分配指向 的指针。首先，两者都不会编译，因为要编译它们，您需要将其声明为指向向量指针的向量的指针，并且您不想这样做，因为在内部管理自己的动态内存分配——避免必须打电话，这是您首先使用 a 的主要原因。vectorOfVectorsAddEmptyVector()vectorOfVectorsstd::vectornewdeletestd::vector
于 2014-01-26T13:09:27.537 回答