C++ 内存管理（memory Management） part1

最新推荐文章于 2024-08-14 09:22:15 发布
最新推荐文章于 2024-08-14 09:22:15 发布
阅读量1.2k 收藏
点赞数
分类专栏： C++ 文章标签： C++ 内存分配 内存管理 内存泄露


首先说说constructors(建构子)这个类的特殊的成员函数。

当一个类的instance被创建时， 会呼叫建构子以对对象的数据初始化。

例如如下例：

声明一个整数的类：

#include <iostream>
using namespace std;

class Integer {
   private:
      int val;
   public:
      Integer() {
         val = 0;
         cout << "default constructor" << endl;
      }
}; //分号不能少

int main() {
   Integer i;
   return 0;
}


运行结果为：

 

不难发现， 上述主程序中子调用了默认建构子。

当我们创建an array of objects的时候， 默认建构子会逐一调用（必须有默认建构子， 才可以创建an array of objects）。

#include <iostream>
using namespace std;

class Integer {
   private:
      int val;
   public:
      Integer() {
         val = 0;
         cout << "default constructor" << endl;
      }
}; //分号不能少

int main() {
   Integer arr[3];
   return 0;
}


程序运行结果为：

 

当在一个类中使用了另一个类声明的对象作为其成员变量， 此时城建这个类的对象的时候， 也会调用内部那个嵌入类的constructor, 以便对其初始化。

例：

#include <iostream>
using namespace std;

class Integer {
   private:
      int val;
   public:
      Integer() {
         val = 0;
         cout << "Integer default constructor" << endl;
      }
}; //分号不能少

class IntegerWrapper {
   private:
      Integer val;
   public:
      IntegerWrapper() {
         cout << "IntegerWrapper default constructor" << endl;
      }
};

int main() {
   IntegerWrapper q;
   return 0;
}


运行结果为：

 

Constructor 也可以有参数， 但是此时该建构子不是默认的construtor, 以便传递参数更好地初始化。 此时， 我们必须定义（写明）默认的建构子。 否则默认的建构子 not available。 如果不写明默认建构子， 一个缺点就是无法什么 array of objects  without initializing了。

例如， 下面的两个程序是错误的：

#include <iostream>
using namespace std;

class Integer {
   private:
      int val;
   public:
      Integer(int v) {
         val = v;
         cout << "Integer default constructor" << endl;
      }
}; //分号不能少


int main() {
   Integer i(3);//ok
   Integer j;// error
   return 0;
}


上述代码会出错， 再例如：

#include <iostream>
using namespace std;

class Integer {
   private:
      int val;
   public:
      Integer(int v) {
         val = v;
      }
}; //分号不能少


int main() {
   Integer a[] = {Integer(2), Integer(5)};//ok, initializing
   Integer b[2];// error, without initializing
   return 0;
}


下面修改如上的代码， 两种办法， （1）单独写一个默认的建构子（默认的就是没有参数的）

（2）采用函数的default 用一个建构子代表两个建构子（一个有参数， 一个是无参数的默认建构子）：

#include <iostream>
using namespace std;

class Integer {
   private:
      int val;
   public:
      Integer(int v) {
         val = v;
      }

      Integer() {
         val = 0;
      }
}; //分号不能少


int main() {
   Integer a[] = {Integer(2), Integer(5)};//ok, initializing
   Integer b[2];//okay 
   return 0;
}


上述的代码是correct的。

 

this 指针

当一个method的参数的名字和类的一个field同名的时候， 如何去区分呢， 这就用到了this指针。 this指向当前调用这个方法的对象的位置。

例如：

class Integer {
   private:
      int val;
   public:
      Integer(int val = 0) { //default parameter
         this -> val = val;
      }
      void setVal(int val) {
         this -> val = val;
      }

}; //分号不能少

 

接下来， 说说Scoping and Memory

 

每当我们声明一个新的变量的时候（int x)， 编译器就会给这个变量x 分配（allocate）一个内存。 当这个变量go out of scope 的时候， 这个内存就会被释放掉（be freed up）, 以便这个内存位置可以分配给其他变量。

例如：

int main() {
   if (true) {
      int x = 5; //declare a variable, allocate memory
   } 
   // x now out of scope, memory it used to occupy can be reused
}


一句话， 当一个variable goes out of scope， that memory is no longer guaranteed to store the variables value。

在举一个例子：

int main() {
   int *p;
   if (true) {
      int x;
      p = &x;
   }
   cout << *p << endl; // ???, x is out of scope, so it will get wrong answer
   return 0;
}


上个例子会出错。

具体分析内存分配如下面几幅图：

 

 

上图中， 最后一幅图不难看出， 变量x goes out of scope, 所以该内存（用于存储5的memory）被释放掉了。 也就是说， 此时指针p变成了一个dangling pointer（也就是说指针指向的memory的contents 是未定义的（undefined））。 

 

A problematic Task

Implement a function which returns a pointer to some memory containing the integer 5.

下面的实现的函数是incorrect的,原因是变量x 是在function scope 中， 该函数返回的时候， x 就会go out of scope。 所以此时返回的指针就变成了一个dangling pointer。

int *getPtrToFive() {
   int x = 5;
   return &x;
}

int main() {
   int *p = getPtrToFive();
   cout << *p <<　endl; //??
}



 

 

 

 

 

 

上述函数的实现方法是不正确的。 走出这个dilemma的方法就是我们动态的分配内存。这种动态分配的内存会一直remian 下去直到我们manually de-allocate it。

动态分配内存用到了new operator，此时返回一个pointer 指向the newly allocated memory.  如下句：

int *x = new int;

 

NOTE:

——如果使用 int x; 分配的内存区域在the stack （栈）中

——如果使用 new int; 分配的内存区域在the heap （堆）中。

 

要释放由 new operator 分配在heap 中的内存， 必须使用delete operator 手动释放的。 （这两个运算符需要配套使用， 使用完毕后， 用delete释放动态内存）。

int *getPtrToFive() {
   int *x = new int;
   *x = 5;
   return x;
}

int main() {
   int *p = getPtrToFive(); //动态分配内存的时候对指针的初始化
   cout << *p <<　endl; //5
   delete p;
}

 

注意， 如果使用完后， 不用delete 去deallocate由new 分配的动态内存， 那么我们编写的application 就会waste memory。

如下例：

int *getPtrToFive() {
   int *x = new int;
   *x = 5;
   return x;
}

int main() {
   for (int i = 0; i < 3; ++i) {
      p = getPtrToFive();
      cout << *p << endl;
   }
}


具体分析如下：

上述的程序错误的原因在于没有deallocate 分配的动态内存。

 

再比如， 下面的例子， 虽然delete了， 但是只是deallocate 最后一次分配的动态、内存：

int *getPtrToFive() {
   int *x = new int;
   *x = 5;
   return x;
}

int main() {
   for (int i = 0; i < 3; ++i) {
      p = getPtrToFive();
      cout << *p << endl;
   }
   delete p; 
}


 

 

上述的语句时不正确的， 因为它导致了memory leak(内存泄露)。 要想修正这个错误， 从而避免内存泄露， 把delete的语句放在loop内：

 

int *getPtrToFive() {
   int *x = new int;
   *x = 5;
   return x;
}

int main() {
   for (int i = 0; i < 3; ++i) {
      p = getPtrToFive();
      cout << *p << endl;
      delete p;
   }
   
   return 0;
}

 

注意， 删除heap中的动态内存之后， 就不要再使用分配的内存了：

int *getPtrToFive() {
   int *x = new int;
   *x = 5;
   return x;
}

int main() {
   int *p = getPtrToFive(); //动态分配内存的时候对指针的初始化
   delete p;
   cout << *p; // error
}

必须在使用之后， 不再需要了， 才删除：

int *getPtrToFive() {
   int *x = new int;
   *x = 5;
   return x;
}

int main() {
   int *p = getPtrToFive(); //动态分配内存的时候对指针的初始化
   cout << *p <<　endl; //5
   delete p;
   return 0;
}


注意， 同一个内存空间删除两次：

int *getPtrToFive() {
   int *x = new int;
   *x = 5;
   return x;
}

int main() {
   int *p = getPtrToFive(); //动态分配内存的时候对指针的初始化
   cout << *p <<　endl; //5
   delete p; delete p; // error
   return 0;
}

 

只有用new 分配的动态内存才可以使用delete operator：

int main() {
   int x = 5;
   int *xPtr = &x;
   cout << *xPtr << endl;
   delete xPtr; //error
   return 0;
}

上面是错误的， 应该使用：

int main() {
   int x = 5;
   int *xPtr = &x;
   cout << *xPtr << endl;
}


Allocating Arrays

在stack 中声明数组时（分配内存）， 我们必须指定数组的size 为常量， 不能为变量。也就是说：

int arr[SIZE];// size 必须为常量

例如， 下面的语句时错误的：

int numItems;
cout << "How many items?";
cin >> numItems;
int arr[numItems]; // not allowed


要想实现动态的分配数组的内存， 必须使用 new [] , 这时候， 数组可以有variable size, 例如：

int numItems;
cout << "How many items?";
cin >> numItems;
int *arr= new int[numItems];


具体分析如下：

 

删除动态数组的内存， 使用的是 delete[], 如下：

 

int numItems;
cout << "How many items?";
cin >> numItems;
int *arr= new int[numItems];
delete[] arr;


下面举个例子：

#include <iostream>
using namespace std;
int main() {
   int numItems;
   cout << "How many items?";
   cin >> numItems;
   int *arr = new int[numItems];
   for (int i = 0; i < numItems; ++i) {
      cout << "Enter item" << i << ":";
      cin >> arr[i];
   }
   for (int i = 0; i < numItems; ++i) {
      cout << arr[i] << endl;
   }
   delete[] arr;
   return 0;
}


运行结果如下：





 

JUAN425
关注
专栏目录
##Memory Management (内存管理)
q_k
12-21 2520
Memory Management (内存管理)首先要知道为什么要进行内存管理? 资源最大化利用,众所周知,不管是计算机还是移动设备单片机等的内存都是有限的,如何在有限的内存空间运行更多更大的程序就是每一个内存管理系统所要考虑的问题,通过控制所有对象的生命周期,从而减少内存的占用,让程序之后不使用的对象释放自己的内存空间怎么判断这个对象在以后的程序中不会使用了呢?C 和 C++有严格的申请内存和释放
C++内存管理
lesky的专栏
12-25 7558
C++内存管理[导语]内存管理是C++最令人切齿痛恨的问题，也是C++最有争议的问题，C++高手从中获得了更好的性能，更大的自由，C++菜鸟的收获则是一遍一遍的检查代码和对C++的痛恨，但内存管理在C++中无处不在，内存泄漏几乎在每个C++程序中都会发生，因此要想成为C++高手，内存管理一关是必须要过的，除非放弃C++，转到Java或者.NET，他们的内存管理基本是自动的，当然你也放弃了自
C++：Memory Management
WEEKS7518的博客
09-28 466
浅谈C++内存管理 new和delete 在C++中，我们习惯用new申请堆中的内存，配套地，使用delete释放内存。 class LiF; LiF* lif = new LiF(); // 分配内存给一个LiF对象 delete lif; // 释放资源 lif = nullptr; // 指针置空，保证安全 与C的malloc相比，我们发现，new操作在申请内存的同时还完成了对象的...
Memory Management
aerkate的专栏
06-21 632
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.
C++ 内存管理库 ＜memory＞
最新发布
Aforxiaoxie的博客
08-14 1164
memory>很抱歉，因为我这几天生病了，所以没有更新，希望大家能谅解。我们进入正题！
虚拟机内存管理之内存分配器
YZcoder的博客
09-01 2189
本文意在通过深入剖析常用的内存分配器的关键实现，以理解虚拟机动态内存管理的设计哲学，并为实现虚拟机高效的内存管理提供指引。
Detailed Analysis of Memory Management and Technology in Keil5
# Detailed Explanation of Memory Management and Analysis Techniques in Keil5 ## Chapter 1: Introduction and Overview of Keil5 ### Introduction to the Keil5 Integrated Development Environment (IDE) ...
c++编程思想part3
10-28
8. **动态内存管理（Dynamic Memory Management）**：C++提供了`new`和`delete`操作符来动态分配和释放内存，同时，智能指针（如auto_ptr、unique_ptr、shared_ptr）可以帮助开发者更安全地管理内存，防止内存泄漏。...
C++ Crash Course- A Fast-Paced Introduction 2019.rar
09-03
Part 1 covers the core of the C++ language, where you’ll learn about everything from types and functions, to the object life cycle and expressions. Part 2 introduces you to the C++ Standard Library ...
c++编程思想part2
10-28
7. **动态内存管理（Dynamic Memory Management）**：涉及new和delete操作符，以及智能指针（如auto_ptr、unique_ptr、shared_ptr）。这部分内容将讲解如何有效地分配和释放内存，防止内存泄漏。 8. **多态...
Memory Management in C++
jackmacro的专栏
10-15 1986
<br />Memory Management in C++<br />by Nathan C. Myers <br />Memory usage in C++ is as the sea come to land: <br />a tide rolls in, and sweeps out again, <br />leaving only puddles and stranded fish. <br />At intervals, a wave crashes ashore; but the <br /
C++ memory management
XD的2013
10-13 499
1. vector 1. 1 After vector is allocated, the memory it occupies is not freed until destructor is called, even if v.clear() is called. To explicitly deallocate this piece of memory, use this tri
c++ memory 内存管理学习（转）
02-13 1416
本系列文章，主要是学习c++内存管理这一块的学习笔记。 时间：6.7-21 之下以技术内幕的开头语，带入到学习C++内存管理的技术中吧： 内存管理是C++最令人切齿痛恨的问题，也是C++最有争议的问题，因此要想成为C++高手，内存管理一关是必须要过的！ 笔记汇总： 1.C++内存管理学习笔记（1） 2.C++内存管理学习笔记（2） 3.C++内存管理学习笔记（3） 4.C++内存管...
Memory management
diaoju3333的博客
07-28 181
https://en.wikipedia.org/wiki/Memory_management Memory managementis a form ofresource managementapplied tocomputer memory. The essential requirement of memory management is to provide ways t...
C/C++内存泄漏及检测
weixin_34362790的博客
02-20 2241
  “该死系统存在内存泄漏问题”，项目中由于各方面因素，总是有人抱怨存在内存泄漏，系统长时间运行之后，可用内存越来越少，甚至导致了某些服务失败。内存泄漏是最难发现的常见错误之一，因为除非用完内存或调用malloc失败，否则都不会导致任何问题。实际上，使用C/C++这类没有垃圾回收机制的语言时，你很多时间都花在处理如何正确释放内存上。如果程序运行时间足够长，如后台进程运行在服务器上，只要服务器不宕...
深入了解C++ memory_order
weixin_39413616的博客
06-15 1565
C++ memory order的深入理解
C++STL之memory
zidian666的博客
01-19 423
allocator，分配内存但不进行任何初始化，很少用 shared_ptr 共享指针，初始化后同指针一样指向一个对象，成员函数use_count() 表示有多少共享指针指向对象，每当shared_ptr被赋值、拷贝的时候，use_count()加1，一个共享指针不再指向对象时，use_count减1。以这种方式构造的，指向同一个对象的指针，use_count是共享的。 不要使用同一个对象初始化多个共享指针。一个对象只能初始化一个共享指针。其成员函数get()可返回对象类型的指针，也不要用这个指针初始化
C++ memory order循序渐进（二）—— C++ memory order基本定义和形式化描述所需术语关系详解
wxj1992的博客
12-22 7655
目录1.c++的六种memory_ordermemory_order_relaxedmemory_order_consumememory_order_acquirememory_order_releasememory_order_acq_relmemory_order_seq_cstSequenced-beforeCarries dependencyModification orderReleas...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值