如何在c ++中传递"this"

Question

我对thisC++中的关键字很困惑,我不确定如果我通过传递做正确的事情this.这是我正在努力解决的一段代码:

ClassA::ClassA( ClassB &b) {

    b.doSth(this);
    // trying to call b's routine by passing a pointer to itself, should I use "this"?
}

ClassB::doSth(ClassA * a) {
       //do sth
}

Answer 1

你正确使用它.this指针指向当前对象实例.

class helper 
{
public:
     void help(worker *pWorker) {
          //TODO do something with pWorker . . .
     }

     void help2(worker& rWorker) {
          //TODO do something with rWorker . . .
     }
};

class worker 
{
public:
     void dowork() {
          //this one takes a worker pointer so we can use the this pointer.
          helper.help(this);

          //to pass by reference, you need to dereference the this pointer.
          helper.help2(*this);
     }
     helper helper;
};

另外,说你宣布worker *pW = new worker().如果你在pW对象上调用其中一个方法(dowork),你会注意到this指针和pW具有完全相同的值(它们都是相同的地址).

(没有测试过,以确保它的构建,但我认为它应该).

Answer 2

在C++中,this是一个关键字,它被定义为"指向当前对象实例的指针".所以上面的代码是正确的.

根据ClassA和之间的继承/组合关系ClassB,可能有更好的方法来实现您正在做的事情,而不是使用this指针.

Answer 3

正如你所做的那样,传递'this'或'*this'是完全可以的.

终身危险:

关于你提供的例子的一点是,你是doSth从构造函数调用的ClassA.传递给的对象doSth可能是部分构造的对象:

class ClassC {
public:
  ClassC ()
  : m_c ()
  {}
  int m_c;
};

class ClassA : public ClassC {
public:
  ClassA (ClassB & b)
  : ClassC ()
  , m_b ( b.doSth (this) )  // ClassC constructed
                            // ClassA members partially init.
  {
    b.doSth (this);         // ClassA members initialized
  }

  // ...
  int m_a;
};

class ClassD : public ClassA {
public:
  ClassD(ClassB & b)
  : ClassA (b)              // Partially init
  , m_d ()
  {
                            // ClassC and ClassA constructed
                            // ClassD members initialized
  }
  int m_d;
};

如果doSth使用尚未初始化的成员,可能会出现问题:

void ClassB::doSth (ClassA * a) {
  int i = a->m_c;     // OK m_c is initialized

  int j = a->m_a;     // Not OK, m_a not initialized when called
                      // from member initialization list.

  int k = static_cast<ClassD*> (a).m_d;  // Not OK
}

使用对象的动态类型:

最后,对象的动态类型的任何使用(例如,虚拟调用,dynamic_cast,typeid)在部分构造的对象上将比在完整对象上具有不同的结果(并且在某些情况下,您可以具有未定义的行为).

void ClassB::doSth (ClassA * a) {
  if (ClassD * d = dynamic_cast<ClassD *> (a))
  {
    // Never true when called from ClassA::ClassA
  }
}

Answer 4

在本例中，usingthis会将指向调用者类（即 A）的指针传递给 b.DoSth。看来你做得对。this关键字始终指向您从中使用它的类实例。