为什么C++顺序访问迭代器的函数签名不使用指针？

例如，在这段代码中，beg&end似乎用作指针。但是在*BEG中的函数声明中，在*Enter中既不提供，也不接受C++编译器。为什么我们像指针一样使用它，而不是像函数的指针参数一样声明它

#include <vector>
#include <algorithm>
#include <iostream>
#include <iterator>
using namespace std;

template<class In, class X> void myreplace (In beg, In end, const X& x, const X& y)
{
    while (beg != end)
    {
        if (*beg == x) *beg = y;
        beg++;
    }
}

int main()
{
    vector<int> veca = { 1, 3, 4, 4, 1, 4, 4 };
    myreplace(veca.begin(), veca.end(), 4, 2);
    copy(veca.begin(), veca.end(), ostream_iterator<int>(cout, ","));
}

---

通过重载一元运算符*函数，可以为任何使用定义的类型定义解引用运算符

veca.begin返回的类型就是这样的类型。该类型的对象可以使用*运算符取消引用

标准库中大多数容器的begin成员函数返回的迭代器都支持这种操作。因此，您可以使用：

std::vector<int> a = {10, 20, 30};
std::vector<int>::iterator iter = a.begin();
int item = *iter;

及

及

---

通过重载一元运算符*函数，可以为任何使用定义的类型定义解引用运算符

veca.begin返回的类型就是这样的类型。该类型的对象可以使用*运算符取消引用

标准库中大多数容器的begin成员函数返回的迭代器都支持这种操作。因此，您可以使用：

std::vector<int> a = {10, 20, 30};
std::vector<int>::iterator iter = a.begin();
int item = *iter;

及

及

通常不仅仅是指针，而是指针的抽象

根据他们的意见：

<>他们的语义是C++中指针的大部分语义的概括。这确保了每个使用迭代器的函数模板都可以与 常规指针

因此，您也可以这样做：

myreplace(&veca[0], &veca[6], 4, 2);

其中&veca[0]和&veca[6]是指向向量veca的第一个和最后一个元素的指针

这是可能的，因为返回对指定位置元素的引用。

通常不仅仅是指针，而是指针的抽象

根据他们的意见：

<>他们的语义是C++中指针的大部分语义的概括。这确保了每个使用迭代器的函数模板都可以与 常规指针

因此，您也可以这样做：

myreplace(&veca[0], &veca[6], 4, 2);

其中&veca[0]和&veca[6]是指向向量veca的第一个和最后一个元素的指针

---

这是可能的，因为返回对指定位置元素的引用。

您是指以下正确代码：

template<class In, class X> void myreplace (In* beg, In* end, const X& x, const X& y)
{
    while (*beg != *end)
    {
        if (**beg == x) **beg = y;
        *beg++;
    }
}

---

您的意思是正确的代码如下：

template<class In, class X> void myreplace (In* beg, In* end, const X& x, const X& y)
{
    while (*beg != *end)
    {
        if (**beg == x) **beg = y;
        *beg++;
    }
}

---

没有什么能阻止你向myreplace传递指针。e、 g.在电话中

int Carray[7] = { 1, 3, 4, 4, 1, 4, 4 };
myreplace(Carray, Carray + 7, 4, 2);

中的模板参数被推断为int*，X被推断为int。这与您编写的相同

void myreplace (int * beg, int * end, const int & x, const int & y)
{
    while (beg != end)
    {
        if (*beg == x) *beg = y;
        beg++;
    }
}

---

它还接受行为与指针非常相似的非指针，即model

没有任何东西可以阻止您将指针传递给myreplace。e、 g.在电话中

int Carray[7] = { 1, 3, 4, 4, 1, 4, 4 };
myreplace(Carray, Carray + 7, 4, 2);

中的模板参数被推断为int*，X被推断为int。这与您编写的相同

void myreplace (int * beg, int * end, const int & x, const int & y)
{
    while (beg != end)
    {
        if (*beg == x) *beg = y;
        beg++;
    }
}

---

它还接受行为完全类似于指针的非指针，即model

迭代器是用于迭代它们所属的底层容器的抽象。因为它们按特定于容器的顺序指向元素，所以它们被用作指针。否则，它们就是对象。迭代器概念的要点是，您可以抽象出如何迭代集合的关注点，并且只依赖于标准的公开迭代器方法。迭代器是迭代它们所属的底层容器的抽象。因为它们按特定于容器的顺序指向元素，所以它们被用作指针。迭代器概念的要点是，您可以抽象出如何迭代集合的问题，而只依赖于标准的公开迭代器方法。