C++ 使用迭代器修改c++；

当我试图编写一个insert函数时，会出现问题，该函数假定将数组中的所有元素向上移动到迭代器指定的位置，然后在迭代器指定的位置向数组中插入一个新值

代码在插入函数中出现错误，错误如下：

“运算符[]”不匹配（操作数类型为“std:：basic_string[1000]”和“std:：basic_string”）

我不熟悉使用迭代器，我认为不可能使用指针作为索引来访问数组元素。因此，我不确定是否有其他方法可以做到这一点，或者我是否需要重载[]操作符以使其以某种方式工作

template <class T>
class Vector {
    public:
        typedef T* iterator;
        Vector () {  }

        T& operator[](unsigned int i) {
           return items[i];
        }
          // T& operator[](iterator i) {
           //return items[*i];
        //}

        iterator begin () {
            return &items[0];
        }
        iterator end () { 
            return &items[used];
        }
        int size () { return used; }

        iterator insert (iterator position, const T& item) { 

            for(Vector<T>::iterator i=&items[998]; i>=position; i--)
            {
                items[*(i+1)]=items[*i];
            }
            items[*position]= item;

            return position;
        }
    private:
        T items[1000];
        int used=0;
};

模板
类向量{
公众：
typedef T*迭代器；
向量（）{}
T运算符[]（无符号整数i）（&T）{
退货项目[i]；
}
//T&运算符[]（迭代器i）{
//退货项目[*i]；
//}
迭代器begin（）{
退货和项目[0]；
}
迭代器结束（{
返回和项目[已使用]；
}
int size（）{return used；}
迭代器插入（迭代器位置，常量T&item）{
对于（向量：：迭代器i=&items[998]；i>=位置；i--）
{
项目[*（i+1）]=项目[*i]；
}
项目[*位置]=项目；
返回位置；
}
私人：
T项[1000]；
int=0；
};

此代码有问题，因为它创建了1000个T类型的元素，即使逻辑上是空的。此外，如果插入超过1000个，则会丢弃上面的元素

至于编译问题，我尝试使用

Vector

编译代码，它编译得很好，但崩溃了。出于同样的原因，它与

Vector

一起崩溃，而不是与

Vector

一起编译。问题在于

*i

的类型，即

std:：string

在

Vector

的情况下。要么一直使用迭代器，要么使用索引，但不要混合使用。使用迭代器：

        for(Vector<T>::iterator i=&items[998]; i>=position; i--)
        {
            *(i+1)=*i;
        }

此外，请注意，回路后面的线也应固定：

        items[*position]= item; // <--- BUG: also mixing indexes and iterators

---

除了的答案外，我还试图让它工作（因此需要更长的时间）

因此，他第一次提出的修复方案

items[*position]= item;

改为

*position = item;

编译并运行以下测试：

#include <iostream>

int main()
{
  Vector<double> vec;
  vec.insert(vec.begin(), 1.0);
  vec.insert(vec.begin(), 2.0);
  vec.insert(vec.begin(), 3.0);
  std::cout << "vec.size(): " << vec.size() << '\n';
  for (int i = 0; i < vec.size(); ++i) {
    std::cout << "vec[" << i << "]: " << vec[i] << '\n';
  }
  return 0;
}

哎呀

insert（）

中也缺少对所用

的更新：

++used;

现在看起来好多了：

vec.size（）：3
vec[0]：3
vec[1]：2
vec[2]：1

全文如下：

#包括
模板
类向量{
公众：
typedef T*迭代器；
向量（）{}
T运算符[]（无符号整数i）（&T）{
退货项目[i]；
}
//T&运算符[]（迭代器i）{
//退货项目[*i]；
//}
迭代器begin（）{
退货和项目[0]；
}
迭代器结束（{
返回和项目[已使用]；
}
int size（）{return used；}
迭代器插入（迭代器位置，常量T&item）{
对于（向量：：迭代器i=&items[998]；i>=位置；i--）
{
*（i+1）=*i；
}
*位置=项目；
++使用；
返回位置；
}
私人：
T项[1000]；
int=0；
};
int main（）
{
向量向量机；
vec.insert（vec.begin（），1.0）；
向量插入（向量开始（），2.0）；
向量插入（向量开始（），3.0）；
std:：cout因此，您可以将此上下文中的迭代器视为指向数组中元素的美化指针，正如您在类开头的typedef中定义的那样

当您试图在insert函数中访问数组中的元素时，实际上是取消对这些指针的引用以生成元素本身，然后将这些元素用作数组的索引，从而产生索引类型错误的错误

例如，假设您有一个
向量
。在insert函数的for循环中，您有以下行：

items[*(i+1)]=items[*i];

因为
i
是您定义的
迭代器
，
i
的类型为
std:：string*
，因此
*i
的类型为
std:：string
。当您编写
项[*i]
时，您正试图使用
std:：string
作为数组的索引，而您不能这样做

相反，应使用类似于以下内容的行：

*(i + 1) = *i

您的代码中还存在一些逻辑错误，但稍后我会让您查找这些错误

希望这能有所帮助！
看看如何实现

template< class BidirIt1, class BidirIt2 >
BidirIt2 move_backward(BidirIt1 first, BidirIt1 last, BidirIt2 d_last)
{
    while (first != last) {
        *(--d_last) = std::move(*(--last));
    }
    return d_last;
}

请注意，如果您试图插入完整的
向量
T items[1000]；
是C数组而不是
向量，则这是未定义的，因此
向量：：迭代器i=&items[998]；
格式不正确
：
i
类型为
T*
*i
以及
*（i+1）
类型为
T&
（对
T
的引用）。因此，
项[*（i+1）]
没有意义。（如果我正确理解的话，
*（i+1）=*i；
）@RichardCriten抱歉，它不是
Vector
std:：Vector
。我相信，OP试图重建它是为了教育目的。@Scheff你是对的-我需要读得更慢更准确。迭代器不是索引，不能用作索引。迭代器被当作指针使用。在你的情况下，它是指针。将它用作索引指针：
*位置=项；
。
items[*(i+1)]=items[*i];

*(i + 1) = *i

template< class BidirIt1, class BidirIt2 >
BidirIt2 move_backward(BidirIt1 first, BidirIt1 last, BidirIt2 d_last)
{
    while (first != last) {
        *(--d_last) = std::move(*(--last));
    }
    return d_last;
}

iterator insert (iterator position, const T& item) { 
    for(iterator i = end(), d = end() + 1; i != position; )
    {
        *(--d) = std::move(*(--i));
    }

    *position = item;
    ++used;

    return position;
}