Do you use automatic garbage collection with standard C++?

Question

I'm interested in a rough measure (percentage-wise) of how many use garbage collection, such as the Boehm collector, with standard C++.

Under what circumstances would you use garbage collection, and when wouldn't you, with C++? Are there other alternatives?

Answer 1

I have, but at least for me it seemed to cause more problems than it solved. Using GC with C++ basically makes it much more like other languages that use GC -- in particular, you lose the deterministic destruction of objects that's (more or less) necessary for RAII to work correctly. This, in turn, means that when (for example) you want to destroy something deterministically, you need to do so explicitly like you do in something like Java. IMO, that's somewhat clumsy in Java -- but much more so in C++, since it lacks a finally clause for the purpose.

Under normal circumstances, you can use a dtor and RAII to provide all the capabilities of a finally clause, but the whole problem here is that with GC you no longer get that. That means almost any time you want to destroy something deterministically, you need to do so explicitly and throw (pun noted by not intended) in extra try/catch clauses to ensure that it happens no matter how you exit the area where you needed the resource.

In the end, it comes down to one thing: at least for me, GC accomplishes next to nothing, because intelligent use of container classes has basically eliminated memory management problems without it. RAII allows me to manage memory and virtually all other resources cleanly. Using GC means 1) the memory isn't managed as well (memory footprint is generally considerably larger), and 2) I have to go back to managing other resources manually.

Answer 2

I use garbage collection with smart pointers (Boost's shared_ptr). It's mostly used for large objects that are shared throughout the system. It encourages passing the pointer around and ensures the object is destroyed at some point.

I also use the shared pointers with a publish/subscribe type system. Mostly because I don't know how many handlers are going to have access to the same event pointer and I don't have a definite lifetime for that event.

I will admit that using the shared pointers for the objects has caused more trouble than help at certain points. Mostly because these objects have a clear and definite time of destruction/creation and there's no need for them to be garbage collected. In fact, it keeps hiding errors where an object is holding onto a subsystem for too long and the subsystems are being destroyed in the incorrect order.

I have never used a garbage collector similar to the one that's used for Java. Didn't know those existed.