[C++]存储区域及其功能特点

C++ 有几个特定的区域用来存储对象或非对象值，每个区域有其各自的特点。
https://stackoverflow.com/questions/14588767/where-in-memory-are-my-variables-stored-in-c
Global variables -------> data
Static variables -------> data
Constant data types -----> code
Local variables (declared and defined in functions) --------> stack
Variables declared and defined in main function -----> heap
Pointers (for example, char *arr, int *arr) -------> heap
Dynamically allocated space (using malloc and calloc) --------> stack
http://pierre.aubert.free.fr/divers/gotw/gotw009a.html

\[\begin{array} {c|c} \text{区域} & \text{功能特点} \\ \hline \\ \hline 常量数据 & 常量数据区存储了字符和其他在编译期间就已经知道的数据。类类型的对象不能存储在这个区域。所有在这个区域的数据都在程序的整个生命周期有效。这里的所有数据都是只读数据，也就是说修改数据这个行为在这里是未定义的，一部分原因是鸡屎树底层的存储格式也是受制于实现的随即优化的。比如说，对于某个特定的编译器，数组可能被存储在重叠的对象(overlapping objects)中，如果它想的话。 \\ \hline 栈& 栈区存储了自动变量。通常比动态存储（堆或者自由存储区）要快，因为存储的分配(allocation)只涉及指针的增长而没有更复杂的存储管理。当存储空间被分配后对象立即就被构造，而对象析构后存储空间也能立即被释放。因此，程序员没有机会直接地操作已分配且未初始化的栈空间（禁止使用显式dtor故意篡改和放置new （barring willful tampering using explicit dtors and placement new）） \\ \hline 自由存储区 & new \\ \hline 常量存储区 & 存储常量数据 \\ \hline 静态存储区 & 存储静态成员变量 \\ \end{array}\]

在C++里，通常new出来的对象时在空闲存储区里的，而malloc出来的空间则是在堆里。
空闲存储区的第一个特点时，其中分配的对象没有名字。new表达式没有返回实际分配的对象，二十返回指向该对象的指针。对该对象的全部操作都要通过这个指针间接完成。例如：

int* pi = new int;

该new表达式会创建一个int型对象，由pi指向它。
空闲存储区的第二个特点时，分配的内存未初始化。空闲存储区的内存包含随机的位模式。它是程序运行前该内存上次被使用留下的结果。

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 .

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!