Novice heap questions.

Would there be any benefit in this pointless example to having the data of ObjectTwo be declared separately on the heap? Is not the member from ObjectOne not on the free strore? What is/are the difference(s) aside from how you access said data?

Code:

---

class ObjectOne
{
  public:
      int data;
};

class ObjectTwo
{
  ObjectTwo() {data = new int;}
  ~ObjectTwo() { delete data; }

      int * data;
};

int main()
{
  ObjectOne * classOne = new ObjectOne();
  ObjectTwo * classTwo = new ObjectTwo();

  delete classOne;
  delete classTwo;

return 0;
}

---

If it is just an int, probably not.

But once you have such pointers in your class, obey the rule of three.
Rule of three (C++ programming) - Wikipedia, the free encyclopedia

Btw, you have the nomenclature backwards, interchange your ClassX and ObjectX names here.
These minor details are rather important to understand object oriented programming properly.

Yes, you are definitely right to point those out, poor on my part - and no excuse for rushing. It is annoying that I cannot edit it immediately actually.

Expanding on the question though, is there some convention for explicitly slotting everything to the heap? As an example, your correction of my poor naming above. Should it just be done all the time, even in simple constructs? In a 'pick one way and do it that one way all the time' ideal.

Do whichever is simpler.
(I always put builtin types and the standard containers directly)

Only use pointers when the object is of an incomplete type. (say..forward declared classes)
This helps reduce clutter in the header files and improve compilation times.
A (common?) pattern for that is to put all private data behind a pointer to a large object.
( Opaque pointer - Wikipedia, the free encyclopedia )

Quote:

---

Originally Posted by manasij7479

Only use pointers when the object is of an incomplete type. (say..forward declared classes)

---

references work with forward declarations too, but then they must be initialized in the constructor initializer list, and only if the constructor is defined such that the definition of what the reference refers to is fully valid at that point in the code.