Question

我对C ++中的this关键字感到困惑，我不确定如果我通过传递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

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

Answer 5

this是指向对象实例的指针，所以你所做的是正确的。

阅读this了解详情。

Answer 6

this是指向自己对象的const指针。 this指针是不可修改的。

  ClassA::ClassA( ClassB &b) {

        b.doSth(this);
        // here 'this' refers to this object ie the instance of ClassA. 
        // When you pass 'this' to doSth function --> is equivalent to passing 
        // the instance of current object of ClassA.
        //   
    }

如何在c ++中传递“this”

6 个答案: