Memory Management

Memory Management - Part I
Difficulty: 3 / 10

This GotW covers basics about C++'s main distinct memory stores. The following problem attacks some deeper memory-management questions in more detail.

Problem

C++ has several distinct memory areas where objects and non-object values may be stored, and each area has different characteristics.

Name as many of the distinct memory areas as you can. For each, summarize its performance characteristics and describe the lifetime of objects stored there.

Example: The stack stores automatic variables, including both builtins and objects of class type.

Solution

The following summarizes a C++ program's major distinct memory areas. Note that some of the names (e.g., "heap") do not appear as such in the draft [standard].

 Memory Area     Characteristics and Object Lifetimes
 --------------  ------------------------------------------------

 Const Data      The const data area stores string literals and
                 other data whose values are known at compile
                 time.  No objects of class type can exist in
                 this area.  All data in this area is available
                 during the entire lifetime of the program.

                 Further, all of this data is read-only, and the
                 results of trying to modify it are undefined.
                 This is in part because even the underlying
                 storage format is subject to arbitrary
                 optimization by the implementation.  For
                 example, a particular compiler may store string
                 literals in overlapping objects if it wants to.


 Stack           The stack stores automatic variables. Typically
                 allocation is much faster than for dynamic
                 storage (heap or free store) because a memory
                 allocation involves only pointer increment
                 rather than more complex management.  Objects
                 are constructed immediately after memory is
                 allocated and destroyed immediately before
                 memory is deallocated, so there is no
                 opportunity for programmers to directly
                 manipulate allocated but uninitialized stack
                 space (barring willful tampering using explicit
                 dtors and placement new).


 Free Store      The free store is one of the two dynamic memory
                 areas, allocated/freed by new/delete.  Object
                 lifetime can be less than the time the storage
                 is allocated; that is, free store objects can
                 have memory allocated without being immediately
                 initialized, and can be destroyed without the
                 memory being immediately deallocated.  During
                 the period when the storage is allocated but
                 outside the object's lifetime, the storage may
                 be accessed and manipulated through a void* but
                 none of the proto-object's nonstatic members or
                 member functions may be accessed, have their
                 addresses taken, or be otherwise manipulated.


 Heap            The heap is the other dynamic memory area,
                 allocated/freed by malloc/free and their
                 variants.  Note that while the default global
                 new and delete might be implemented in terms of
                 malloc and free by a particular compiler, the
                 heap is not the same as free store and memory
                 allocated in one area cannot be safely
                 deallocated in the other. Memory allocated from
                 the heap can be used for objects of class type
                 by placement-new construction and explicit
                 destruction.  If so used, the notes about free
                 store object lifetime apply similarly here.


 Global/Static   Global or static variables and objects have
                 their storage allocated at program startup, but
                 may not be initialized until after the program
                 has begun executing.  For instance, a static
                 variable in a function is initialized only the
                 first time program execution passes through its
                 definition.  The order of initialization of
                 global variables across translation units is not
                 defined, and special care is needed to manage
                 dependencies between global objects (including
                 class statics).  As always, uninitialized proto-
                 objects' storage may be accessed and manipulated
                 through a void* but no nonstatic members or
                 member functions may be used or referenced
                 outside the object's actual lifetime.

Note about Heap vs. Free Store: We distinguish between "heap" and "free store" because the draft deliberately leaves unspecified the question of whether these two areas are related. For example, when memory is deallocated via operator delete, 18.4.1.1 states:

It is unspecified under what conditions part or all of such reclaimed storage is allocated by a subsequent call to operator new or any of calloc, malloc, or realloc, declared in <cstdlib>.

Similarly, it is unspecified whether new/delete is implemented in terms of malloc/free or vice versa in a given implementation. Effectively, the two areas behave differently and are accessed differently -- so be sure to use them differently!

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值