как передать «это» в с ++

Вы правильно его используете. Указатель 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 () . Если вы вызовете один из методов (dowork) для объекта pW , вы заметите, что указатель this и pW имеют одинаковое значение (они оба имеют одинаковый адрес).

(не тестировал это, чтобы убедиться, что он работает, но я думаю, что должен).

В C ++ this является ключевым словом, которое определяется как «указатель на текущий экземпляр объекта». Итак, ваш приведенный выше код верен.

В зависимости от отношения наследования / композиции между ClassA и ClassB , вероятно, есть более эффективные способы добиться того, что вы делаете, чем использование этот указатель.

Совершенно нормально передавать «это» или «* это», как вы это делаете.

Жизненные опасности:

Один из моментов в приведенном вами примере заключается в том, что вы вызываете 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
  }
}

В этом случае при использовании этот передаст указатель на класс вызывающего абонента, которым является A, в b.DoSth. Похоже, вы все делаете правильно. это ключевое слово всегда указывает на экземпляр класса, из которого вы его используете.

this - указатель на экземпляр объекта, поэтому то, что вы делаете, правильно.

Прочтите это для получения дополнительной информации.

this является const указатель на собственный объект. этот указатель не подлежит изменению.

  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.
        //   
    }