Directory of Memory Management Resources

Home > Top > Computers > Programming > Languages > C++ > Memory Management

C++ usually doesn't provide automatic garbage collection. Some C++ features, and much C++ code is poorly suited for AGC, so programmers must explicitly deal with memory management issues, which can get quite difficult and needs much time.

Resources in This Category

• "Pure Virtual Function Called": An Explanation

  http://www.artima.com/cppsource/pure_virtual.html
  This article provides an in-depth look at the "pure virtual function called" error message.

• A Garbage Collection Framework for C++

  http://www.codeproject.com/Articles/912/A-garbage-collection-framework-for-C
  An article on using garbage collection through the use of smart pointers.

• A Garbage Collection Framework for C++, Part II

  http://www.codeproject.com/Articles/938/A-garbage-collection-framework-for-C-Part-II
  This article deals with refactoring the code originally presented in part 1 in order to allow polymorphic types to be used.

• A Generic Non-intrusive Smart Pointer Implementation

  http://www.justsoftwaresolutions.co.uk/articles/genericptr.pdf
  This article follows through the implementation of a smart pointer class that overcames deficiencies of existing smart pointer implementations.

• An Introduction to Garbage Collection, Part II

  http://www.icu-project.org/docs/papers/cpp_report/an_introduction_to_garbage_collection_part_ii.html
  Show how garbage collection works and what it actually costs.

• C++ Memory and Resource Management

  http://www.informit.com/articles/article.aspx?p=30642
  Stephen Dewhurst discusses how the various features of C++ are used together in memory management, how they sometimes interact in surprising ways, and how to simplify their interactions.

• C++ Memory Management: From Fear to Triumph, Part 1

  http://www.linuxdevcenter.com/pub/a/linux/2003/05/08/cpp_mm-1.html
  This article discusses C++ in the context of several other popular languages. It also describes the kinds of memory errors that can occur in C++ programs.

• C++ Memory Management: From Fear to Triumph, Part 2

  http://www.linuxdevcenter.com/pub/a/linux/2003/06/19/cpp_mm-1.html
  This article explains design principles that will help keeping memory management error out of C++ code.

• C++ Memory Management: From Fear to Triumph, Part 3

  http://www.linuxdevcenter.com/pub/a/linux/2003/08/07/cpp_mm-3.html
  Presents a list of simple, powerful techniques that can be used to deal with memory in C++ programs.

• Containers in Memory: How Big Is Big?

  http://www.gotw.ca/publications/mill14.htm
  Answers the question of how much memory the various standard containers use to store the same number of objects of the same type T.

• Counted Body Techniques

  http://www.boost.org/community/counted_body.html
  Introduces two key concepts: the use of a generic requirements based approach to simplify and adapt the use of the counted body pattern and the ability to dynamically and non-intrusively add capabilities to fixed types using the runtime mixin pattern.

• Memory Hygiene in C and C++: Safe Programming with Risky Data

  http://www.informit.com/articles/article.aspx?p=169586
  Memory management is scary. It should be: A lot can go wrong--often very wrong. But a moderately experienced C or C++ programmer can learn and understand memory hazards completely.

• Memory Management in C++

  http://www.cantrip.org/wave12.html
  Covers the design of a global memory manager that is as fast and space-efficient as per-class allocators.

• Smart Pointers

  http://www.informit.com/articles/article.aspx?p=25264
  Andrei Alexandrescu navigates through the sometimes treacherous waters of using smart pointers, which imitate built-in pointers in syntax and semantics but perform a host of additional tasks that built-in pointers can't.

• Smart Pointers in Boost

  http://www.drdobbs.com/cpp/smart-pointers-in-boost/184401507
  Introduces smart pointers and takes a look at Boosts various smart pointer templates (scoped_ptr, scoped_array, shared_ptr, and shared_array).

• Smart Pointers in C++

  http://www.informit.com/articles/article.aspx?p=31529
  Andrei Alexandrescu discusses smart pointers, from their simplest aspects to their most complex ones and from the most obvious errors in implementing them to the subtlest ones--some of which also happen to be the most gruesome.

• Smart Pointers: What, Why, Which?

  http://ootips.org/yonat/4dev/smart-pointers.html
  Explains what smart pointers are, why they should be used, and which one should be used.

• The Rule of The Big Two

  http://www.artima.com/cppsource/bigtwo.html
  Matthew and Bjorn update the well-known Rule of The Big Three, explaining which one of those member functions is not always needed.

• To New, Perchance to Throw, Part 1

  http://www.gotw.ca/publications/mill15.htm
  Explains why a class that provides its own class-specific operator new(), or operator new[](), should also provide corresponding class-specific versions of plain new, in-place new, and nothrow new.

• To New, Perchance to Throw, Part 2

  http://www.gotw.ca/publications/mill16.htm
  Delves deeper into the question of what operator new() failures mean, and how best to detect and handle them.

• Using auto ptr Effectively

  http://www.gotw.ca/publications/using_auto_ptr_effectively.htm
  Explains why auto_ptr neatly solves common C++ design and coding problems, and why using it can lead to more robust code.

Related Categories

• Home > Top > Computers > Programming > Memory Management

 

Home > Top > Computers > Programming > Languages > C++ > Memory Management

 

---

 

Thanks to DMOZ, which built a great web directory for nearly two decades and freely shared it with the web. About us