C++ 理解。以向量开始和结束

我在学习向量，它们从迭代器开始。它们定义.开始和.结束如下：

begin（）–返回指向向量中第一个元素的迭代器

end（）–返回一个迭代器，该迭代器指向 跟随向量中的最后一个元素

然后他们给出了下面的代码片段，我添加了第三个for循环来表达我的问题

#include<iostream>
#include<vector>

int main() {
    std::vector <int> g1; //creating a vector
    for (int i = 1; i <= 3; i++){
        g1.push_back(i);
    }
    std::cout << "Output of beginning and end values: ";
    for (auto i = g1.begin(); i != g1.end(); i++) {
        std::cout << *i << " "; 
    }
    std::cout << "\nOutput of beginning and end addresses: ";
    for (auto i = g1.begin(); i != g1.end(); i++) {
        std::cout << &i << " ";
    }
     //"Output of beginning and end values: 1 2 3"
     //"Output of beginning and end addresses: 0105FB0C 0105FB0C 0105FB0C"
    return 0;
}

#包括
#包括
int main（）{
std:：vector g1；//创建一个向量
for（int i=1；i
&i
是局部变量
i
的地址。这不会更改。
*i
取消对迭代器的引用，并返回向量中该元素的值。
&*i
将返回指向向量中元素的指针

所以你应该使用循环

std::cout << &*i << " ";

std:：cout
&i
是局部变量
i
的地址。这不会更改。
*i
取消对迭代器的引用，并返回向量中该元素的值。
&*i
将返回指向向量中元素的指针

所以你应该使用循环

std::cout << &*i << " ";

std:：cout
我想我可能把迭代器和指针混淆了

指针是迭代器，这是可以理解的。但并不是所有的迭代器都是指针。换句话说，非指针也可以是迭代器

我知道auto基本上是类型推断，但仅此而已

在这种情况下，类型被推断为
std:：vector:：iterator
，因为这是
std:：vector:：begin
返回的类型

所以我的问题是，如果向量中的每个元素的地址都相同，那么i的值是如何变化的

i
的值由循环中的
i++
更改。对象的存储地址在对象的整个生命周期内都不会更改。无论该对象的类型是指针，其他某个迭代器还是根本不是迭代器

我想我可能把迭代器和指针混淆了

指针是迭代器，这是可以理解的。但并不是所有的迭代器都是指针。换句话说，非指针也可以是迭代器

我知道auto基本上是类型推断，但仅此而已

在这种情况下，类型被推断为
std:：vector:：iterator
，因为这是
std:：vector:：begin
返回的类型

所以我的问题是，如果向量中的每个元素的地址都相同，那么i的值是如何变化的

<> > <代码> i>代码>在循环中由<代码> i++>代码>更改。对象存储的地址永远不会在对象的生命周期内发生变化。无论该对象的类型是指针还是其他迭代器，也不是一个迭代器。
< P>以更清楚的方式考虑类似的代码，而不是向量T。这里使用了一个数组

#include <iostream>
#include <iterator>

int main() 
{
    int a[] = { 1, 2, 3 };

    for ( auto p = std::begin( a ); p != std::end( a ); p++ )
    {
        std::cout << "The address of p is " << &p
                  << ", its value is " << p
                  << ", and the pointed value is " << *p
                  << '\n';
    }

    return 0;
}

这是输出字符串的一部分

The address of p is 0x7ffcaf6a6830

未更改，因为它是局部变量（指针）p本身的地址

这部分弦

its value is 0x7ffcaf6a683c

and the pointed value is 1

正在更改，因为在循环中指针的值已更改

for ( auto p = std::begin( a ); p != std::end( a ); p++ )
                                                        ^^^^

在每次迭代中，指针指向数组的下一个元素

这部分弦

its value is 0x7ffcaf6a683c

and the pointed value is 1

也正在更改，因为由于取消引用指针而输出了指向的值

向量迭代器也发生同样的事情。
为了更清楚地考虑一个类似的代码，而不是一个向量，使用了一个数组。
#include <iostream>
#include <iterator>

int main() 
{
    int a[] = { 1, 2, 3 };

    for ( auto p = std::begin( a ); p != std::end( a ); p++ )
    {
        std::cout << "The address of p is " << &p
                  << ", its value is " << p
                  << ", and the pointed value is " << *p
                  << '\n';
    }

    return 0;
}

这是输出字符串的一部分

The address of p is 0x7ffcaf6a6830

未更改，因为它是局部变量（指针）p本身的地址

这部分弦

its value is 0x7ffcaf6a683c

and the pointed value is 1

正在更改，因为在循环中指针的值已更改

for ( auto p = std::begin( a ); p != std::end( a ); p++ )
                                                        ^^^^

在每次迭代中，指针指向数组的下一个元素

这部分弦

its value is 0x7ffcaf6a683c

and the pointed value is 1

也正在更改，因为由于取消引用指针而输出了指向的值

向量的迭代器也会发生同样的情况。
i
是一个迭代器，它的行为“像”一个指针。它包含某种类型的句柄（可以是指针，也可以是索引），可用于（a）在集合中移动，以及（b）定位集合的当前元素。如果您查看
g1[i]
和
&i
在第一个循环中，您还会有相同的问题吗？如果没有，为什么？想象一下如果
i
只是一个
int*
。这可能有助于理解发生了什么。请注意，与其他容器不同，
T*
是
std:：vector
的有效迭代器类型，因此比较非常准确。“因此，如果地址没有改变，就必须改变
i
的值，这样才能有一个不同的值”-这就是循环中的
i++
语句。它使迭代器提前引用向量中的下一个元素
i
是迭代器，其作用类似于指针。它包含某种类型的句柄（可以是指针，也可以是索引），可用于（a）在集合中移动，以及（b）定位集合的当前元素。如果查看
g1[i]
和
&i
在第一个循环中，您还会有相同的问题吗？如果没有，为什么？想象一下如果
i
只是一个
int*
。这可能有助于理解发生了什么。请注意，与其他容器不同，
T*
是
std:：vector
的有效迭代器类型，因此比较非常准确。“因此，如果它的地址没有改变，就必须改变
i
的值，这样它才能有不同的值“-这将是循环中的
i++
语句。它使迭代器前进，以引用向量中的下一个元素谢谢！我看到地址在更改，但它们相距4个字节。即00F6E3B8 00F6E3BC 00。”