How to combine `this` and pointer in c++?

Question

I am learning C++. There is a curious case and I want to know the solution. Suppose the code is as following

class HumanBeing {
private:
    string *name;
    int *age;

    HumanBeing(string name, int age) {
        // what to do in here?
    }
};

In Java I can use this.name = name. But in C++ I can do this->name = name(it is not valid for above example), but what to do when the class variable is a pointer?

I am from Java background so these(pointers) things are very confusing for me.

Answer 1

I would avoid using pointers in this example and rewrite it like this:

class HumanBeing {
private:
    string name;
    int age;
public:
    HumanBeing(string name, int age) : name (name), age (age) 
    {
    }
};

The above example initializes you data members using a constructor initialization list.

If you choose to use pointers anyway, then you have to decide how owership of the data will be handled.

If your class will take ownership of the data, then you can do what tp1 suggested.

If your class will not take ownership of the data, then you can do this:

    HumanBeing(string &name, int &age) : name (&name), age (&age) 
    {
    }

If you have access to C++11 and still want to use pointers, I would suggest at least using smart pointers.

Answer 2

try

this->name = new string(name);
this->age = new int(age);

But I would recommend renaming the parameters so that there is no confusion whether you use the parameter or member variable.

Answer 3

Your logic is correct. You should be able to write this->name = name. I believe your problem is that the class variable 'name' is pointer to string string * while the parameter you're receiving in your constructor is a string string. Try changing this:

private:
  string *name;
  int *age;

To this:

private:
  string name;
  int age;

UPDATE: If you want to use pointers then you must pass a pointer.

MyClass(string *name, int *age)
{
  this->name = name;
  this->age = age;
}

Or you could pass by reference and have a similar behavior to Java.

private:
  string *name;
  int *age;

MyClass(string &name, int &age)
{
  this->name = &name;
  this->age = &age;
}

Thanks @user007

Answer 4

HumanBeing is a constructor. Whenever possible, you should use the base/member initializer syntax of a constructor to initialize the members and base class portions:

HumanBeing(string name, int age)
: name(name)  // error!
, age(age)    // error!
{
    // what to do in here? Nothing!
}

However, that won't work here (see error! comments) because the members age and name are pointers.

This is a problem, because the constructor arguments are temporary objects. We must not store, inside the class object, pointers to temporary objects. And so we cannot fix it like this, even though it compiles:

HumanBeing(string name, int age)
: name(&name) 
, age(&age)
{
}

The parameter objects name and age cease to exist when the constructor terminates, and so the object's members are left pointing to garbage.

You must redesign the constructor with a different interface, or redesign the class so that its members aren't pointers.

// Alternative constructor: get stable objects from somewhere

HumanBeing(string *n, int *a) : name(n) , age(a) { }

// Alternative class design

class HumanBeing {
private:
    string name;
    int age;

    HumanBeing(string n, int a)
    : name(n)
    , age(a)
    {
    }
};

There is rarely any need to fuss around with the this pointer. The main use is when a non-static member function needs to call another function in another class, or a non-class function, and needs to pass a pointer to its object. For instance:

// FooClass derives from NotificationTarget
// The this pointer is FooClass *, and
// implicitly converts to NotificationTarget * in the RegisterMe call.

FooClass::RegisterForNotification(NotificationSource &ns)
{
  ns.RegisterMe(this);   // void NotificationSource::RegisterMe(NotificationTarget *);
}

The this pointer can be used to overcome a scoping problem in C++:

int xl;  // at file scope

class funny {
  int x1;

  void method()
  {
     xl = 1;  // TYPO! assigns to xl at file scope, not x1 member.
     this->xl = 1; // TYPO! But caught by compiler. 
  }
};

This doesn't add up to a reason to use this->member all over the place in C++ programs; you must use sane naming conventions to defend against this type of problem, such as using g_ prefix on globals, and m_ on members, or a similar convention.

Answer 5

Pointers are just variables that hold a memory address. They do not hold any data value, they just hold a memory address to the data. Don't think of them as something too complicated.

class HumanBeing {
private:

    // just holds a memory address (size 4 for 32-bits, 8 for 64 bits)
    string *name;

    // just holds a memory address (size 4 for 32-bits, 8 for 64 bits)
    int *age;

    HumanBeing(string name, int age) {
        // These lines use new to allocate memory from the heap and
        // initialize them with the parameters passed.
        // Then they return memory addresses that are stored in
        // this->name and this->age
        this->name = new string(name);
        this->age = new int(age);
    }
};

If you want to use pointers in more code: this->name is a memory address *(this->name) dereferences that memory address and gives the value where that memory address is located.

Also beware anytime you use new, you have to delete the allocated memory to prevent memory leaks when you're not using it anymore because C++ doesn't have the convenient resource expensive garbage collector that Java has.