指向指针的指针'；s属性 在C++中，有什么方法可以模拟这种情况？

我有两个对象

A

和

B

，每个对象都有一个属性，例如

inti

； 还有一个指针指向一个对象，一个指针指向一个整数。我想让整数指针指向指针指向当前对象中的属性。 比如：

po = A;
pi = po->i;
// pi points to A.i
po = B;
// now pi points to B.i

我几乎可以肯定这不能用指针来实现，但我想知道是否有什么工作可以做

struct S {
   int i;
};


S a, b;
A * ap = & a;
int * ip = &(ap->i);

---

ip现在指向a i成员（注意这些不是C++中的属性）

，如您所写的：

当采购订单指向B时，pi继续指向A.i

使用有什么问题

po = &A;
// do stuff using po and po->i (A and A.i)

po = &B;
// do stuff using po and po->i (B and B.i)

---

简而言之，这不能按您指定的方式完成。你也不会真的想要它

想象一下，如果更改一个变量也更改了其他完全不同的变量，那么应用程序会陷入混乱。就像猫和狗住在一起一样。集体歇斯底里症

但是，完全按照你的要求去做也没有什么意义，这让我觉得你真正想要的完全是别的东西。例如，在上面的示例中，只需执行以下操作就会简单得多：

po = A;
int ai = po->i;
po = B;
int ab = po->i;

---

那么，您真正想做什么呢？

您正在寻找的是所谓的“指向成员的指针”。假设A和B的类型为T，则可以编写：

struct T { int i; };
T A, B, C; // some objects of this type

int T::*pi = &T::i; // pi is a pointer to an int member of T

T* po;
po = &A;
cout << po->*pi << '\n'; // prints A.i
po = &B;
cout << po->*pi << '\n'; // prints B.i

cout << C.*pi << '\n'; // prints C.i

struct{int i；}；
T A，B，C；//这种类型的某些对象
int T:：*pi=&T：：i；//pi是指向T的int成员的指针
T*po；
po=&A；
cout*pi实际上你不能直接这么做。
如果
po
发生变化，则必须通知/更改
pi
。随着
pi
成为新type
AutoReference
的对象，您可以实现它，但没有人会理解代码。
我所说的“不直截了当”的意思是：以下方法可行，但不可行

class AutoReference
{
public:
  AutoReference( ClassA ** ppObj )
  : mppObj( ppObj )
  {
  }

  ClassA * operator->()
  {
    return *mppObj;
  }

private:
  ClassA ** mppObj;
};


po = A;
AutoReference pi( &po );
// pi "points" to A.i
po = B;
// now pi "points" to B.i

struct O
{
int i；
};
结构P
{
无效运算符=（O&rhs）
{
po=&rhs；
pi=&rhs.i；
}
O*po；
int*pi；
};
int main（）
{
P po；
int*&pi=po.pi；
O A，B；
A.i=7；
B.i=19；
po=A；
这可能行得通，但我觉得这很难看

class MyObject
{
public:
 int m_i;

};

class AutomaticPointerToMember
{
    public:
 AutomaticPointerToMember(MyObject& obj,int MyObject::*):
 m_Object(obj),
 m_pInt(NULL)
 {}

    operator int* ()
 {
  return &(m_Object.*m_pInt);
 }

 int operator* ()
 {
  return (m_Object.*m_pInt);
 }

private:
 MyObject& m_Object;
 int MyObject::* m_pInt;
};

void test()
{
 MyObject a;
 MyObject b;

 MyObject * pObj =  &a;
 AutomaticPointerToMember pi(*pObj, &MyObject::m_i);

 int * pIa = pi; // pIa  points to a.i
    int ia = *pi; // value a.i

 pObj = &b; // pObj now points to b

 int * pIb = pi; // pIb  points to b.i

    int ib = *pi; // value b.i
}

还必须定义运算符&、*&等等，以便定义一个政治上正确的智能指针…
或者你可以只做一个指向指针的指针，如果这更适合你的情况的话

T a, b;
a.i = 6;
b.i = 9;

T* po = &a;
T** pi = &po;
std::cout << (*pi)->i;  // Prints 6

po = &b;
std::cout << (*pi)->i;  // Prints 9

ta，b；
a、 i=6；
b、 i=9；
T*po=&a；
T**pi=&po；
std:：cout i；//打印6
po=&b；
std:：cout i；//打印9
这不是OP要求的。他想要一种方法，当
po
被更改时，自动更改
pi
的值。他说“我想让整数指针指向指针指向当前对象中的属性”这就是我发布的代码所做的。阅读他的代码示例中的注释-这就是@Space_C0wb0y提到的需求的表达。好吧，这是一个有效的问题，但它并不试图回答OP的实际问题。是的，这可能是OP真正想要的。但这不是要求的，这就是我要求进一步澄清的原因。+1不完全是。你说（意译）“为什么不这样做？”我说“你不能那样做。你真正想做什么？在你精心设计的例子中，为什么不这样做？”这可以通过一些行为类似于指向int的指针的结构来实现，但它包含对其他指针的引用，以及对成员的一个指针。但是，真的，为什么要使事情复杂化呢？不管你想实现什么，肯定有一种更优雅的方式。我猜，根据你的描述，B是从a派生出来的（您正在分配指针。）如果是这样的话，A:：i和B:：i是一样的。在任何人能够帮助你之前，你需要澄清你实际上在做什么。不过，说真的，我不会在真正的代码中使用这种魔法-为什么你不简单地为
i
提供一个访问器方法呢？实际上我不喜欢这个名称
自动引用
：-（+1）您还应该实现运算符和*，以便提供完整的智能指针。但我更喜欢您的想法，它比我的更简单，重量更小。
T a, b;
a.i = 6;
b.i = 9;

T* po = &a;
T** pi = &po;
std::cout << (*pi)->i;  // Prints 6

po = &b;
std::cout << (*pi)->i;  // Prints 9