Why doesn’t C++ have a garbage collector?

by

Implicit garbage collection could have been added in, but it just didn’t make the cut. Probably due to not just implementation complications, but also due to people not being able to come to a general consensus fast enough.

A quote from Bjarne Stroustrup himself:

I had hoped that a garbage collector
which could be optionally enabled
would be part of C++0x, but there were
enough technical problems that I have
to make do with just a detailed
specification of how such a collector
integrates with the rest of the
language, if provided. As is the case
with essentially all C++0x features,
an experimental implementation exists.

There is a good discussion of the topic here.

General overview:

C++ is very powerful and allows you to do almost anything. For this reason it doesn’t automatically push many things onto you that might impact performance. Garbage collection can be easily implemented with smart pointers (objects that wrap pointers with a reference count, which auto delete themselves when the reference count reaches 0).

C++ was built with competitors in mind that did not have garbage collection. Efficiency was the main concern that C++ had to fend off criticism from in comparison to C and others.

There are 2 types of garbage collection…

Explicit garbage collection:

C++0x has garbage collection via pointers created with shared_ptr

If you want it you can use it, if you don’t want it you aren’t forced into using it.

For versions before C++0x, boost:shared_ptr exists and serves the same purpose.

Implicit garbage collection:

It does not have transparent garbage collection though. It will be a focus point for future C++ specs though.

Why Tr1 doesn’t have implicit garbage collection?

There are a lot of things that tr1 of C++0x should have had, Bjarne Stroustrup in previous interviews stated that tr1 didn’t have as much as he would have liked.

More Related Contents:

  1. Garbage Collection in C++ — why?
  2. what is the concept of evaluation of expression z = (y = 30) + (y = 10) + (y = 20); [closed]
  3. Is cout synchronized/thread-safe?
  4. Why C++11 in-class initializer cannot use parentheses?
  5. Sorting zipped (locked) containers in C++ using boost or the STL
  6. Is local static variable initialization thread-safe in C++11? [duplicate]
  7. What does the thread_local mean in C++11?
  8. Selecting a member function using different enable_if conditions
  9. How to make generic computations over heterogeneous argument packs of a variadic template function?
  10. When to use std::begin and std::end instead of container specific versions [duplicate]
  11. How does the range-based for work for plain arrays?
  12. How to set the stacksize with C++11 std::thread
  13. C++ memory model and race conditions on char arrays
  14. In C++11, does `i += ++i + 1` exhibit undefined behavior?
  15. Can someone please explain the “indices trick”?
  16. Proper way to create unique_ptr that holds an allocated array
  17. What exactly is an R-Value in C++?
  18. std::unique_ptr, deleters and the Win32 API
  19. Difference between std::system_clock and std::steady_clock?
  20. Default template argument when using std::enable_if as templ. param.: why OK with two template functions that differ only in the enable_if parameter?
  21. Is there a range class in C++11 for use with range based for loops?
  22. std::auto_ptr to std::unique_ptr
  23. How can I use C++ 11 features in Clang?
  24. The new keyword “auto”; When should it be used to declare a variable type? [duplicate]
  25. Understanding rvalue references
  26. Equivalent of “using namespace X” for scoped enumerations?
  27. error for hash function of pair of ints
  28. Does C++11 change the behavior of explicitly calling std::swap to ensure ADL-located swap’s are found, like boost::swap?
  29. How does “using std::swap” enable ADL?
  30. Is it safe to reinterpret_cast an enum class variable to a reference of the underlying type?

Leave a Comment