Question

I am learning pointers in c++ and am having some trouble.
I have a class Foo that in the header file declares some data:

private:
const Bar *obj;

Where Bar is a class.

Then in the c++ implementation I want to replace *obj so that it points to a completely different Bar object. *obj is constant, so how do I change what is in what *obj points to or rather, what is in memory at *obj? Also in Foo‘s destructor, how do I deallocate *obj?

Answer 1

Given your class definition

class A {
private:
  const Bar *obj;
};

obj is a pointer to a constant Bar object. You can change what that pointer points to, but you cannot change the contents of the object pointed to.

So, if you have a new Bar object and you’d like to change obj so it points to that, you can simply assign the new value:

/* New object: */
Bar *new_bar = new Bar;
/* Change the pointer: */
obj = new_bar;

There are two issues, however.

1. If the new Bar object is created outside the class, you cannot directly assign it to obj because the latter is private. Hence you need a setter function:

   class A {
   private:
     const Bar *obj;
   public:
     void set_obj(const Bar *new_obj) { obj = new_obj; }
   };
   

2. You must determine who will eventually own the Bar object, i.e. who is responsible for freeing the heap space it takes. If the caller is responsible then you can code it as above, i.e. class A will never create new Bar objects, nor delete any. It will just maintain a pointer to Bar objects created and deleted outside the class.

   But if class A above is actually responsible for the memory space taken by the Bar objects, you must use delete obj in the destructor to free the space, and you must also free the space when you get a new Bar object assigned. That is, the set_obj function above needs to be changed to this:

   void set_obj(const Bar *new_obj) { delete obj; obj = new_obj; }
   

   Otherwise you’ll have a memory leak. Similar measures must be taken in the copy constructor (unless you delete it), as well as the assignment operator: Both functions are used whenever a copy of a class A object is made, and in that case you must make sure that you do not simply copy the pointer, but instead allocate fresh space and copy the object (i.e. you must perform a deep copy):

   A(const A& a):obj(new Bar(*a.obj)) {}
   A& operator=(const A& a) { delete obj; obj = new Bar(*a.obj); return *this; }
   

   Having said this, if your class is responsible for the memory space, it is a much better idea to use a smart pointer class instead of a raw pointer. The main reasons are: (i) The above is quite complicated and it’s easy to make mistakes; (ii) The above is still not very good – there may still be memory leaks or worse problems when an exception is thrown, e.g. in the constructor of Bar. C++11 provides a smart pointer class called std::unique_ptr, which seems ideal for your purposes:

   class A {
   private:
     std::unique_ptr<const Bar> obj;
   public:
     ~A() {}
     void set_obj(std::unique_ptr<const Bar> new_obj) { obj = new_obj; }
   };
   

   With this in place, the smart pointer will take care of any memory space that needs to be freed automatically, both at destruction time as well as when a new Bar object is assigned to the pointer.