Garbage collection Libraries in C++ [closed]

Answer 1

I use boehm-gc a lot. It is straight-forward to use, but the documentation is really poor. There is a C++ page, but its quite hard to find.

Basically, you just make sure that every class inherits from their base class, and that you always pass gc_allocator to a container. In a number of cases you want to use libgccpp to catch other uses of new and delete. These are largely high-level changes, and we find that we can turn off the GC at compile-time using an #ifdef, and that supporting this only affects one or two files.

My major problem with it is that you can no longer use Valgrind, unless you turn the collector off first. While turning the collector off is easy to do, and doesn't require recompiling, it's obviously impossible to use it if you start to run out of memory.

Answer 2

Read this and take a good look at the conclusions:

Conclusions

• Complex solution to problem for which simple solutions are widely used and will be improved by C++0x leaving us little need.

• We have little to no experience with the recommended language features which are to be standardized.

• Fixing bad software complex system will never work.

• Recommend minor language changes to improve future GC support - disallow hiding of pointers (xor list trick) as one example.

• Finally - address the "C++ is bad because it has no GC" argument head-on. C++ doesn't generate garbage and so has no need for GC. Clearly Java, C#, Objective C, etc. generate lots of garbage.

Yes the last sentence is subjective and also a part of the holy wars.
I use C++ because I dislike the idea that someone needs to take out the garbage for me.
The city hall does that and that's enough for me.
If you need GC use another language. Pick the right tool for the right job.

Answer 3

The major difficulty with GC's in C++ is the need to handle uncooperative modules, in the GC sense. ie, to deal with libraries that were never written with GC's in mind.

This is why the Boehm GC is often suggested.

Answer 4

The only one I know of is Boehm, which at the bottom is a traditional mark and sweep. It probably uses various techniques to optimize this, but typically incremental/generational/compacting GC's will be hard to create for C++ without going for a managed subset such as what you can get with .Net C++. Some of the approaches that needs to move pointers can be implemented with compiler support for pinning pointers or read/write blocks though, but the effect on performance may be too big, and it isn't necessarily non-trivial changes to the GC.

Answer 5

You can also use Microsoft's Managed C++. The CLR and the GC are very solid and used in server products, but you have to use CLR types for the GC to actually collect - you can't just recompile your existing code and remove all the delete statements.

I would rather use C# to write brand new code, but Managed C++ lets you evolve your code base in a more progressive manner.

Answer 6

The Boehm garbage collector is freely available, and supposedly rather good (no first hand experience myself)

([PDF WARNING]Theoretical paper about C++0x proposal for the Boehm garbage collector)

It was originally said to make C++0x , but will not make it after all (due to time constraints I suppose).

Proprosal N2670 (minimal support for garbage collectors) did get approved in june 2008 though, so as compiler implementations pick up on this, and the standard gets finalised, the garbage collection world out there for C++ is sure to change...