c++ this pointer question

Question

here is the thing, I want to (probably not the best thing to do) have the ability to call some class constructor that receives as a parameter a pointer to the class who's calling (ufff!!!). Well in code looks better, here it goes, as I do it in C#.

public class SomeClass
{
   SomeOtherClass someOtherClass;

   //Constructor
   public SomeClass(SomeOtherClass someOtherClass)
   {
      this->someOtherClass = someOtherClass;
   }
}

public class SomeOtherClass
{

   public SomeOtherMethod()
   {
      SomeClass c = new SomeClass(this);
   }
}

So, How can I achieve the same result in c++? Thanx in advance.

iammilind · Answer 1 · 2011-08-22T07:50:38.373

class SomeOtherClass;  // forward declaration (needed when used class is not visible)
class SomeClass
{
   SomeOtherClass *someOtherClass;
public:
   SomeClass(SomeOtherClass *some) : someOtherClass(some)
   {}  // this is called initialization at constructor (not assignment)
}

class SomeOtherClass
{
public:
   SomeOtherMethod()
   {
      SomeClass *c = new SomeClass(this);
   }
}

Having answered your requirements above, also note that in C++ you really don't need to declare objects always with new. If you declare,

SomeOtherClass someOtherClass;

then it means that you have an object of SomeOtherClass named someOtherClass.

score 2 · Accepted Answer · answered Aug 22 '11 at 07:46

probably not the best thing to do

It might not be a bad idea. However, every time you use pointers in C++, you must be completely clear about how it will be used: what kind of thing is being pointed to (not just the type of the pointer, but scalar vs. array, etc.), how the pointed-at thing gets there (e.g. via new? As part of some other object? Something else?), and how it will all get cleaned up.

How can I achieve the same result in c++?

Almost identically, except of course that C++ does not use new when you create a local instance by value (so we instead write SomeClass c = SomeClass(this);, or more simply SomeClass c(this);), and we must be aware of the pointer vs. value types (so SomeClass::someOtherClass is now a SomeOtherClass *, which is also the type we accept in the constructor). You should also strongly consider using initialization lists to initialize data members, thus SomeClass::SomeClass(SomeOtherClass* someOtherClass): someOtherClass(someOtherClass) {}.

score 1 · Answer 3 · answered Aug 22 '11 at 07:45

1

You can do pretty much the same thing in C++ as well:

class B;

class A
{
public:
  A (B * b) : pb (b) { }

private:
  B * pb;
};

class B
{
public:
  B () : a (this) { }

private:
  A a;
};

The question is, do you really need that?

answered Aug 22 '11 at 07:45

wilx

17,697
6
59
114

I'm trying to implement a game programming framework, and I want it to be in several aspects as xna, so the thing is in xna the Game class, initializes GraphicsDeviceManager which it recieves an object of type Game in its constructor. Any alternatives on getting pretty much the same result, which I think is having only one graphics device manager per game instance. – Yoss Aug 22 '11 at 07:50

score 0 · Answer 4 · answered Aug 22 '11 at 07:55

0

Maybe like this :)

class SomeOtherClass;

class SomeClass
{
private:
  SomeOtherClass * someOtherClass;
public:
  SomeClass(SomeOtherClass *someOtherClass)
  {
    someOtherClass = someOtherClass;
  }
};
class SomeOtherClass
{
public:
  void SomeOtherMethod()
  {
    SomeClass *c = new SomeClass(this);
  }
};

answered Aug 22 '11 at 07:55

tohaz

197
5
19

This is how i tried the first time, but, the "this" pointer is a *const this, and the constructor is expecting a "non const" pointer :) – Yoss Aug 22 '11 at 08:08
1

@Yoss: In C++, there's a difference between `MyClass const*` and `MyClass* const`. In the first case, you can change the pointer but not the `MyClass`. In the second case, you can change `MyClass` but not the pointer. The `this` pointer always points to the current object, i.e. you can't change it. But in C++, you can make a non-const copy of a const object. Therefore, you can always make a copy of `this` which you can subsequently change (point to another `MyClass`. – MSalters Aug 22 '11 at 08:30
you do not mention const's in your question – tohaz Aug 22 '11 at 08:34

score 0 · Answer 5 · answered Aug 22 '11 at 08:44

'this' is a pointer-to-const in member functions (methods) declared as const. So:

void f1(X* p);
void f2(const X* p);

class X {
    void m1() {
        f1(this); // OK
        f2(this); // also OK
    }
    void m2() const {
        f2(this); // OK
        f1(this); // error, 'this' is a pointer to const X
    }
};

c++ this pointer question

5 Answers5