3

If I don't use new to allocate the data members of a class, is there still any clean-up that needs to be done in the destructor? For example, in the following case, will I need to delete the vector? Or does it depend on MyType?

class A {
  A();
  ~A();
  MyType x;
  std::vector<MyType> v;
};
A::A() {
  x = MyType(42);
  v = std::vector<MyType>(5);
}
A::~A() {
  // what goes here?
}
Andreas
  • 7,470
  • 10
  • 51
  • 73

6 Answers6

9

To be pedantic, it depends on what MyType is. If you have typedef char* MyType and you allocate memory for MyType, and you want that memory to be owned by the object, then yes, you need a destructor.

Otherwise, you don't need to free memory for anything that wasn't allocated with new or malloc, so no.

Your class shouldn't even have a destructor at all. There's a general consensus that you should only have a destructor when you actually need it. Having a destructor also implies implementing an assignment operator and copy constructor (the rule of three). If you're not managing any memory, it's better to rely on the ones provided by the compiler - i.e. the compiler will generate these three if you don't.

Also, your constructor should look like this:

A::A() : x(42), v(5){
}

Otherwise your members will be initialized and then assigned to, which is wasteful.

Luchian Grigore
  • 253,575
  • 64
  • 457
  • 625
  • In this particular case, no need for a dtor. Just keep in mind that the "R" in "RAII" stands for *resource*, not *memory*. Sometimes you will need to release something other than memory in a dtor. – John Dibling Jun 13 '12 at 19:11
  • @JohnDibling but this(at least the second part) is based on the assumption that resources are released when their particular owners are destroyed. So if `MyType` acquires a resource and releases it in its destructor, it's ok. – Luchian Grigore Jun 13 '12 at 19:13
  • In that context: one object should manage one resource, max. If you need to manage 2 resources, wrap them in 2 members each of which manages one resource. – MSalters Jun 14 '12 at 09:43
4

Your class does not need an explicit destructor. The vector's destructor will be invoked automatically anyway. And since the vector object itself (as opposed to the data inside) is not dynamic, you don't have to delete it. In fact, that'd be a syntax error, as v is not a pointer.

Seva Alekseyev
  • 59,826
  • 25
  • 160
  • 281
1

The destructors are automatically called, so you don't need to do that. Also, for pointers use smart pointers (such as std::unique_ptr) instead of deleteing them manually.

class A {
  A();
  ~A();
  MyType x;
  std::vector<MyType> v;
};
A::A() : x(42), v(5) { }
A::~A() {
  // x.~MyType() implicitly called.
  // v.~std::vector<MyType>() implicitly called.
}
Community
  • 1
  • 1
1

The vector is automatically deleted at time of destruction. However, if you store pointers in a vector, E.g. If you say vector<Foo *> v;, you'll need write code to delete the pointers in the vector. One way to avoid this is to use vector<std::unique_ptr<Foo>> or vector<std::shared_ptr<Foo>>

S.L. Barth is on codidact.com
  • 8,198
  • 71
  • 51
  • 66
sandhya
  • 11
  • 1
0

No, you don't have to. Their constructors will be called implicitly.

JustSomeGuy
  • 3,677
  • 1
  • 23
  • 31
0

For class A no, you don't, since it doesn't have any pointer member allocated using new or malloc.

Beware that if your class/struct MyType have any pointers as a member, the destructor of MyType is the responsible to free the memory of such pointer, but you don't have to worry with that in class A, since when its destructor is called, the destructor of the vector calls the destructor of MyType.

BrunoB
  • 337
  • 1
  • 4
  • 16