← Back to context

Comment by coherentpony

12 years ago

You still have to 'free' in destructors in C++. Destructors don't free your memory for your custom types for you.

You need to free heap-allocated objects, but stack allocated objects are important and useful (particularly with RAII) and cleanly reversing such allocations eliminates a class of bugs.

  • And of course, you don't even need to explicitly free heap-allocated objects if you're using C++11 smart pointers like shared_ptr and unique_ptr.

    • ... mostly. Much like in a garbage collected language, you need to make sure you are no longer referencing things when you want resources to be freed, but it does make the worst case much harder to run into.

  • Stack allocated objects are cleaned up automatically in C, too...

    • RAII. [1]

      Stack allocated objects have their memory freed in C. Other resources are not released.

      Consider the following C, with and without gcc extensions:

          #include <stdio.h>
          #include <stdlib.h>
          #include <malloc.h>
          #include <fcntl.h>
          #include <unistd.h>
      
          #ifndef GCC_EXTENSIONS
          #define GCC_EXTENSIONS 1
          #endif
      
          int main() {
              {
                  #if GCC_EXTENSIONS
                  void close_fd(int *fdp) {
                      if(*fdp >= 0) close(*fdp);
                  }
                  #else
                  #define __attribute__(...)
                  #endif
          
                  int fd __attribute__((cleanup(close_fd))) = -1;
          
                  fd = open("somefile", O_CREAT | O_WRONLY, 0644);
          
                  system("ls /proc/self/fd");
              }
          
              system("ls /proc/self/fd");
          }
      

      with gcc extensions:

          0 1 2 3 4
          0 1 2 3
      

      without gcc extensions:

          0 1 2 3 4
          0 1 2 3 4
      
      

      [1] http://en.wikipedia.org/wiki/Resource_Acquisition_Is_Initial...

You mean heap allocated types? Stack allocated will be deallocated implicitly.