C++ 朋友迭代器可以访问非静态数据成员吗？

我有一个类a和一个简单（而且非常有限）的迭代器a_迭代器，它指向这个类，并且是它的朋友：

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

class A_iterator{
public:
    A_iterator(int index) : _index(index) {}
    int operator*();
private:
    int _index;
};

class A{
    friend class A_iterator;
public: 
    typedef A_iterator iterator;
    A() {   _elems.push_back(1); _elems.push_back(2);   }   
private:
    static vector<int> _elems;  //line  19
};

vector<int> A::_elems; // line 22

int A_iterator::operator*()
{
    return A::_elems[_index];  //line   26  
}

int main()
{
    A a;
    A::iterator it(0);
    cout << *it << endl; //line 33
}

#包括
#包括
使用名称空间std；
类A_迭代器{
公众：
迭代器（int-index）：_-index（index）{}
int运算符*（）；
私人：
int_指数；
};
甲级{
友元类A_迭代器；
公众：
typedef A_迭代器迭代器；
A（）{u elems.push_back（1）；_elems.push_back（2）}
私人：
静态向量_elems；//第19行
};
向量A:：_elems；//第22行
int A_迭代器：：运算符*（）
{
返回A:：_元素[_索引]；//第26行
}
int main（）
{
A A；
A：：迭代器it（0）；
cout是的，友谊与
静态
和非静态数据成员是正交的。您需要更改迭代器，使其包含对其进行迭代的容器的指针/引用，并使用该指针/引用而不是静态成员：

class A;
class A_iterator{
public:
    A_iterator(A &container, int index) : _index(index), _container(&container) {}
    int operator*();
private:
    int  _index;
    A   *_container;
};
//...
int A_iterator::operator*()
{
    return _container->_elems[_index];  //line   26  
}
int main() {
   A a;
   A::iterator it(a,0);
   std::cout << *it << "\n";
}

A类；
类A_迭代器{
公众：
迭代器（A&container，int-index）：\u-index（index），\u-container（&container）{}
int运算符*（）；
私人：
int_指数；
一个*集装箱；
};
//...
int A_迭代器：：运算符*（）
{
return _container->_elems[_index]；//第26行
}
int main（）{
A A；
A：：迭代器it（A，0）；
std:：cout是的，友谊与
静态
和非静态数据成员是正交的。您需要更改迭代器，使其包含对其进行迭代的容器的指针/引用，并使用该指针/引用而不是静态成员：

class A;
class A_iterator{
public:
    A_iterator(A &container, int index) : _index(index), _container(&container) {}
    int operator*();
private:
    int  _index;
    A   *_container;
};
//...
int A_iterator::operator*()
{
    return _container->_elems[_index];  //line   26  
}
int main() {
   A a;
   A::iterator it(a,0);
   std::cout << *it << "\n";
}

A类；
类A_迭代器{
公众：
迭代器（A&container，int-index）：\u-index（index），\u-container（&container）{}
int运算符*（）；
私人：
int_指数；
一个*集装箱；
};
//...
int A_迭代器：：运算符*（）
{
return _container->_elems[_index]；//第26行
}
int main（）{
A A；
A：：迭代器it（A，0）；
std：：cout，然后在
A
上提供一个迭代器工厂，以与STL保持一致。（STL容器在任何地方都这样做，例如
begin（）
和
end（）
）这在技术上是不必要的，但是
A
的消费者不应该真正知道迭代器是如何构造的。@cdhowie：是的，有很多东西可以改进，最好的方法实际上可能是根本不实现
迭代器
类型…提供
typedef std:：vector:：iteartor迭代器A
中de>并实现
A:：迭代器A:：begin（）{return _elems.begin（）}
（类似于
end（）
）它不应该是
return（*\u container）吗？\u elems[\u index]；
在第26行？无论如何，这是一个很棒的答案。然后在
A
上提供一个迭代器工厂，以与STL保持一致。（STL容器在任何地方都这样做，例如
begin（）
和
end（）
）这在技术上是不必要的，但是
A
的消费者不应该真正知道迭代器是如何构造的。@cdhowie：是的，有很多东西可以改进，最好的方法实际上可能是根本不实现
迭代器
类型…提供
typedef std:：vector:：iteartor迭代器A
中de>并实现
A:：迭代器A:：begin（）{return _elems.begin（）}
（类似于
end（）
）它不应该是
return（*\u container）。\u elems[\u index]；
在第26行吗？无论如何，这是一个很棒的答案。