|
|
1. |
C++ Memory and Resource Management
-
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.
|
|
|
2. |
Memory Hygiene in C and C++: Safe Programming with Risky Data
-
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.
|
|
|
3. |
Smart Pointers
-
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.
|
|
|
4. |
Smart Pointers in C++
-
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.
|
|
|
5. |
The Rule of The Big Two
-
Matthew and Bjorn update the well-known Rule of The Big Three, explaining which one of those member functions is not always needed.
|
|
|
6. |
A Garbage Collection Framework for C++
-
An article on using garbage collection through the use of smart pointers.
|
|
|
7. |
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.
|
|
|
8. |
An Introduction to Garbage Collection, Part II
NEW!
-
Show how garbage collection works and what it actually costs.
|
|
|
9. |
C++ Memory Management: From Fear to Triumph, Part 1
-
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.
|
|
|
10. |
C++ Memory Management: From Fear to Triumph, Part 2
-
This article explains design principles that will help keeping memory management error out of C++ code.
|
|
|
11. |
C++ Memory Management: From Fear to Triumph, Part 3
-
Presents a list of simple, powerful techniques that can be used to deal with memory in C++ programs.
|
|
|
12. |
C++ Tutorial - Dynamic Memory Allocation
-
This tutorial covers dynamic memory allocation in C++ for both single objects and arrays of objects. A common beginner bug, dangling pointers, is also described.
|
|
|
13. |
Containers in Memory: How Big Is Big?
-
Answers the question of how much memory the various standard containers use to store the same number of objects of the same type T.
|
|
|
14. |
Counted Body Techniques
-
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.
|
|
|
15. |
Effective C++ Memory Allocation
-
Using several features of the language, this article presents a framework for resource allocation which is temporally deterministic, provides for callback, provides memory pools, and can provide for deadlock prevention.
|
|
|
16. |
Memory Management in C++
-
Covers the design of a global memory manager that is as fast and space-efficient as per-class allocators.
|
|
|
17. |
Smart Pointers in Boost
-
Introduces smart pointers and takes a look at Boosts various smart pointer templates (scoped_ptr, scoped_array, shared_ptr, and shared_array).
|
|
|
18. |
Smart Pointers: What, Why, Which?
-
Explains what smart pointers are, why they should be used, and which one should be used.
|
|
|
19. |
To New, Perchance to Throw, Part 1
-
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.
|
|
|
20. |
To New, Perchance to Throw, Part 2
-
Delves deeper into the question of what operator new() failures mean, and how best to detect and handle them.
|
|
|
21. |
Using auto_ptr Effectively
-
Explains why auto_ptr neatly solves common C++ design and coding problems, and why using it can lead to more robust code.
|