Question

有没有办法在C ++中模拟这种情况？

我有两个对象A和B，每个对象都有一个属性，例如int i; 此外，我有一个指向一个对象的指针po和一个指向整数的指针pi。我想让整数指针指向指针指向的当前对象中的属性。类似的东西：

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

我几乎可以肯定使用指针无法实现这一点，但我想知道是否有任何工作要做。

Answer 1

您正在寻找的是“指向成员的指针”。假设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

Answer 2

实际上你不能直截了当地做到这一点。如果pi发生更改，则必须通知/更改po。如果pi是新ty 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

Answer 3

struct O
{
    int i;
};

struct P
{
    void operator=(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;
    cout << *pi << endl;
    po = B;   
    cout << *pi << endl;
}

Answer 4

或者你可以做一个指向指针的指针，如果这更适合你的情况。

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

Answer 5

正如你所写的那样：

当po指向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)

Answer 6

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

想象一下，如果更改一个变量也会改变其他完全不同的变量，那么应用程序将会降低应用程序的混乱程度。这就像狗和狗猫住在一起。大规模的歇斯底里。

但是完全按照你所要求的那样做也没什么意义，这让我觉得你之后真正之后完全是另一回事。例如，在上面的示例中，执行此操作会简单得多：

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

那么，你真正尝试做什么？

Answer 7

这样可行，但我发现丑陋。

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
}

并且还必须定义运算符＆amp;，*＆amp;等等，以便定义一个政治上正确的智能指针...

Answer 8

struct S {
   int i;
};


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

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

指向指针属性的指针

8 个答案: