C++中的内存管理

最新推荐文章于 2024-09-22 10:47:56 发布

高山羊

最新推荐文章于 2024-09-22 10:47:56 发布

阅读量477

点赞数

分类专栏： C++ 文章标签： C++ 内存管理

本文链接：https://blog.youkuaiyun.com/huangyang1103/article/details/52336775

版权

C++ 专栏收录该内容

7 篇文章

订阅专栏

C/C++内存布局

http://www.cnblogs.com/clover-toeic/p/3754433.html

名称	存储内容
栈	局部变量、函数参数、返回地址等
堆	动态分配的内存
BSS段	未初始化或初值为0的全局变量和静态局部变量
数据段	已初始化且初值非0的全局变量和静态局部变量
代码段	可执行代码、字符串字面值、只读变量

every process stores data starting at 0x08048000 in 32 bit machine (and 0x00400000 in 64 bit machine).

基本内存分配方式

程序中的全局变量，静态变量等是从静态储存去分配。
局部变量，函数参数等是分配在栈上，有编译器负责，处理器一般内置栈内存分配指令，效率高。
动态分配的内存放在堆上，由程序员控制。

动态内存分配

在C语言中通过 malloc() 和 free() 来分配内存。

C++中新增new 和 delete操作符

malloc和free

void* malloc (size_t size);
void* calloc (size_t num, size_t size);

Allocates a block of memory for an array of num elements, each of them size bytes long, and initializes all its bits to zero.

void* realloc (void* ptr, size_t size);

Reallocate memory block

Changes the size of the memory block pointed to by ptr.

如果大于ptr指向的原有内存大小，会从新分配内存，原有ptr被free掉

void free (void* ptr);

Deallocate memory block

一般能使用栈存储和静态存储就不使用堆。原因是：

堆上分配内存需要调用操作系统的内存管理模块的堆管理器，搜索其中是否有符合要求的空闲的连续字节内存块。如果没有还需要碎片合并。

会带来额外的开销。

需要检查是否分配成功，以及需要显试的free

注意点：

free后，指针仍然存在，只是指向的内容变为了垃圾。
这个时候，这个指针就叫野指针

new 和 delete

三种new

普通的new，如果分配失败，会抛出bad_alloc异常
nothrow new，如果分配失败，返回null指针
placement new，在已经分配的内存中重新调用对象的构造函数

还可以直接调用全局函数 ::operator new()

这个时候分配内存，但是不会构造函数。

// operator new example
#include <iostream> // std::cout
#include <new> // ::operator new

struct MyClass {
int data[100];
MyClass() {std::cout << "constructed [" << this << "]\n";}
};

int main () {

std::cout << "1: ";
  MyClass * p1 = new MyClass;
      // allocates memory by calling: operator new (sizeof(MyClass))
      // and then constructs an object at the newly allocated space

std::cout << "2: ";
  MyClass * p2 = new (std::nothrow) MyClass;
      // allocates memory by calling: operator new (sizeof(MyClass),std::nothrow)
      // and then constructs an object at the newly allocated space

std::cout << "3: ";
  new (p2) MyClass;
      // does not allocate memory -- calls: operator new (sizeof(MyClass),p2)
      // but constructs an object at p2

// Notice though that calling this function directly does not construct an object:
  std::cout << "4: ";
  MyClass * p3 = (MyClass*) ::operator new (sizeof(MyClass));
      // allocates memory by calling: operator new (sizeof(MyClass))
      // but does not call MyClass's constructor

delete p1;
delete p2;
delete p3;

return 0;
}

来自 <http://www.cplusplus.com/reference/new/operator%20new/>

注意使用placement new的析构问题。

placement new 用处

可以管理一片分配的内存，避免反复的释放获取
placement new还可以解决的一个问题是建立带参数的构造函数对象数组。

代码示例如下：

1 class CPong

2 {

3 public:

4 CPong( int m ) : v(m) { std::cout << "CPong ctor." << std::endl; }

6 private:

7 int v;

8 };

9 char* pong = new char[ sizeof(CPong) * 10 ];

10 CPong* pp = (CPong*)pong;

12 for ( int i=0; i<10; ++i )

13 {

14 new (pp+i)CPong(i);

15 }

17 for ( int j=0; j<10; ++j )

18 {

19 pp[j].~CPong();

20 }

22 delete [] pong;

来自 <http://www.cppblog.com/kongque/archive/2010/02/20/108093.html>

使用placement new怎么解决析构以及释放内存

Using the new operator does two things, it calls the function operator new which allocates memory, and then it uses placement new, to create the object in that memory. The delete operator calls the object's destructor, and then calls operator delete. Yeah, the names are confusing.

//normal version                   calls these two functions
MyClass* pMemory = new MyClass;    void* pMemory = operator new(sizeof(MyClass));
                                   MyClass* pMyClass = new( pMemory ) MyClass();
//normal version                   calls these two functions
delete pMemory;                    pMyClass->~MyClass();
                                   operator delete(pMemory);

Since in your case, you used placement new manually, you also need to call the destructor manually. Since you allocated the memory manually, you need to release it manually. Remember, if you allocate with new, there must be a coressponding delete. Always.

来自 <http://stackoverflow.com/questions/8918791/how-to-properly-free-the-memory-allocated-by-placement-new>

也就是本来的new 对应两个操作

分配内存，operator new（）；
调用构造函数，placement new

本来的delete调用两个操作：

调用析构函数
调用operator delete

现在我们既然直接调用构造函数，那么也需要直接的调用析构函数，而且不能调用delete表达式，需要调用operator delete 。例子

What is the right method to delete all the memory allocated here?

  const char* charString = "Hello, World";
  void *mem = ::operator new(sizeof(Buffer) + strlen(charString) + 1);
  Buffer* buf = new(mem) Buffer(strlen(charString));

delete (char*)buf;

  const char* charString = "Hello, World";
  void *mem = ::operator new(sizeof(Buffer) + strlen(charString) + 1);
  Buffer* buf = new(mem) Buffer(strlen(charString));

delete buf;

or are they both same?

The correct method is:

buf->~Buffer();
::operator delete(mem);

You can only delete with the delete operator what you received from the new operator. If you directly call the operator new function, you must also directly call the operator delete function, and must manually call the destructor as well.

来自 <http://stackoverflow.com/questions/6783993/placement-new-and-delete>

1
2
3
4
5
6
7
8
9
10

A *pa1 = new A;

// pa1->~A();
// delete pa1;

B *pb1 = new (pa1) B(5);

pb1->~B();
::operator delete(pb1);
// delete pa1;

如果直接调用delete就会重复调用析构函数，这里需要调用 operator delete