当前位置：文档之家 › 内存溢出总结

内存溢出总结

  • 格式：pdf
  • 大小：114.32 KB
  • 文档页数：4

下载文档原格式

  / 4

合集下载

排查内存溢出的方法和步骤

排查内存溢出的方法和步骤

排查内存溢出的方法和步骤内存溢出是软件开发中常见的问题，它会严重影响程序的性能和稳定性。

为了确保软件的优质运行，及时排查和解决内存溢出问题至关重要。

本文将详细介绍排查内存溢出的方法和步骤。

一、了解内存溢出在排查内存溢出之前，我们需要了解什么是内存溢出。

内存溢出是指程序在运行过程中，申请的内存超过了系统能够提供的最大内存限制，导致程序无法正常运行。

内存溢出主要有以下几种类型：1.堆内存溢出：指程序在堆内存中申请的空间超过了限制。

2.栈内存溢出：指程序在栈内存中申请的空间超过了限制。

3.全局内存溢出：指程序在全局内存中申请的空间超过了限制。

二、排查内存溢出的方法1.分析程序代码（1）检查内存申请和释放的逻辑是否正确。

（2）检查是否存在内存泄露的情况，如已释放的内存还被程序使用。

（3）检查程序中是否存在大量临时对象创建和销毁，导致内存频繁申请和释放。

2.使用内存分析工具（1）Visual Studio Memory Profiler：适用于Windows平台的内存分析工具，可以监测程序运行过程中的内存使用情况，定位内存溢出问题。

（2）Valgrind：适用于Linux平台的内存分析工具，可以检测内存泄露、内存越界等问题。

（3）Xcode Memory Graph：适用于iOS和macOS平台的内存分析工具，可以查看内存使用情况，分析内存泄露等问题。

3.动态监测内存使用在程序运行过程中，实时监测内存使用情况，观察内存是否持续上升。

可以通过以下方法进行动态监测：（1）编写内存监控代码，定期输出程序内存使用情况。

（2）使用操作系统提供的命令行工具，如Windows的任务管理器、Linux的top和ps命令等。

三、排查内存溢出的步骤1.确定内存溢出的类型和范围。

2.使用分析工具或动态监测方法，定位内存溢出的问题代码。

3.修复问题代码，如优化内存申请和释放逻辑、消除内存泄露等。

4.重新运行程序，验证内存溢出问题是否已解决。

几种常见的内存溢出与解决办法

几种常见的内存溢出与解决办法

⼏种常见的内存溢出与解决办法引起内存溢出的原因有很多种，常见的有以下⼏种： 1.内存中加载的数据量过于庞⼤，如⼀次从数据库取出过多数据； 2.集合类中有对对象的引⽤，使⽤完后未清空，使得JVM不能回收； 3.代码中存在死循环或循环产⽣过多重复的对象实体； 4.使⽤的第三⽅软件中的BUG； 5.启动参数内存值设定的过⼩；1.堆设置jvm值的⽅法是通过-Xms(堆的最⼩值)，-Xmx(堆的最⼤值)2.栈设置栈⼤⼩的⽅法是设置-Xss参数3.PermGen space第三个异常是关于perm的异常内容，我们需要的是设置⽅法区的⼤⼩，实现⽅式是通过设置-XX:PermSize和-XX:MaxPermSize参数4.DirectMemory第四个异常估计遇到的⼈就不多了，是DirectMemory内存相关的DirectMemoruSize可以通过设置 -XX:MaxDirectMemorySize参数指定容量⼤⼩，如果不指定的话，那么就跟堆的最⼤值⼀致内存使⽤监控⼯具jvmstat 解決辦法:【情况⼀】：ng.OutOfMemoryError:Javaheapspace：这种是java堆内存不够，⼀个原因是真不够（如递归的层数太多等），另⼀个原因是程序中有死循环； 如果是java堆内存不够的话，可以通过调整JVM下⾯的配置来解决： -Xms3062m -Xmx3062m【情况⼆】 ng.OutOfMemoryError:GCoverheadlimitexceeded 【解释】：JDK6新增错误类型，当GC为释放很⼩空间占⽤⼤量时间时抛出；⼀般是因为堆太⼩，导致异常的原因，没有⾜够的内存。

【解决⽅案】： 1、查看系统是否有使⽤⼤内存的代码或死循环； 2、通过添加JVM配置，来限制使⽤内存： -XX:-UseGCOverheadLimit【情况三】： ng.OutOfMemoryError:PermGenspace：这种是P区内存不够，可通过调整JVM的配置： -XX:MaxPermSize=128m -XXermSize=128m 【注】： JVM的Perm区主要⽤于存放Class和Meta信息的,Class在被Loader时就会被放到PermGenspace，这个区域成为年⽼代，GC在主程序运⾏期间不会对年⽼区进⾏清理， 默认是64M⼤⼩，当程序需要加载的对象⽐较多时，超过64M就会报这部分内存溢出了，需要加⼤内存分配，⼀般128m⾜够。

什么是内存溢出outofmemory？怎么解决

什么是内存溢出outofmemory？怎么解决

什么是内存溢出outofmemory？怎么解决本⽂主要内容来源于⽹络，博主⾃⼰整理⽽成，仅做知识分享，如有侵权请联系，会及时删除。

1.什么是内存溢出？内存溢出是指应⽤系统中存在⽆法回收的内存或使⽤的内存过多，最终使得程序运⾏要⽤到的内存⼤于虚拟机能提供的最⼤内存。

为了解决Java中内存溢出问题，我们⾸先必须了解Java是如何管理内存的。

Java的内存管理就是对象的分配和释放问题。

在Java中，内存的分配是由程序完成的，⽽内存的释放是由垃圾收集器(GarbageCollection，GC)完成的，程序员不需要通过调⽤GC函数来释放内存，因为不同的JVM实现者可能使⽤不同的算法管理GC，有的是内存使⽤到达⼀定程度时，GC 才开始⼯作，也有定时执⾏的，有的是中断式执⾏GC。

但GC只能回收⽆⽤并且不再被其它对象引⽤的那些对象所占⽤的空间。

Java的内存垃圾回收机制是从程序的主要运⾏对象开始检查引⽤链，当遍历⼀遍后发现没有被引⽤的孤⽴对象就作为垃圾回收。

2.为什么会出现内存溢出？常见有以下情况：（1）内存中加载的数据量过于庞⼤，如⼀次从数据库取出过多数据；（2）集合类中有对对象的引⽤，使⽤完后未清空，使得JVM不能回收；（3）代码中存在死循环或循环产⽣过多重复的对象实体；（4）使⽤的第三⽅软件中的BUG；（5）启动参数内存值设定的过⼩3.内存溢出解决⽅法内存溢出虽然很棘⼿，但也有相应的解决办法，可以按照从易到难，⼀步步的解决。

第⼀步，就是修改JVM启动参数，直接增加内存。

这⼀点看上去似乎很简单，但很容易被忽略。

JVM默认可以使⽤的内存为64M，Tomcat默认可以使⽤的内存为128MB，对于稍复杂⼀点的系统就会不够⽤。

在某项⽬中，就因为启动参数使⽤的默认值，经常报“OutOfMemory”错误。

因此，-Xms，-Xmx参数⼀定不要忘记加。

第⼆步，检查错误⽇志，查看“OutOfMemory”错误前是否有其它异常或错误。

oom 内存溢出的排查思路

oom 内存溢出的排查思路

oom 内存溢出的排查思路以OOM（Out of Memory）内存溢出的排查思路为标题，我们将从以下几个方面来探讨如何解决这个问题。

1. 理解OOM内存溢出的原因OOM内存溢出是指应用程序在申请内存时，无法获得足够的内存空间而导致的错误。

这可能是因为应用程序的内存使用超过了系统分配给它的内存限制，或者是由于内存泄漏等问题导致的。

理解OOM的原因对于解决问题至关重要。

2. 分析错误日志在遇到OOM内存溢出问题时，首先应该分析错误日志。

错误日志通常会提供有关错误发生的位置、异常堆栈信息以及导致问题的原因的线索。

通过仔细阅读错误日志，可以确定问题的具体来源，并为解决问题提供指导。

3. 检查代码中的内存泄漏内存泄漏是导致OOM内存溢出的常见原因之一。

在排查问题时，需要仔细检查应用程序的代码，查找可能存在的内存泄漏点。

内存泄漏通常是由于未正确释放对象或者对象的生命周期管理不当导致的。

通过分析代码，可以找到潜在的内存泄漏点，并进行修复。

4. 检查内存使用情况除了检查代码中的内存泄漏，还应该对应用程序的内存使用情况进行监控和分析。

可以通过使用内存分析工具来获取应用程序的内存快照，并查看内存中存在的对象、其大小以及引用关系等信息。

通过对内存使用情况的分析，可以找到内存占用较大的对象，进一步缩小问题的范围。

5. 调整内存配置参数在一些情况下，OOM内存溢出可能是由于应用程序的内存配置参数设置不合理导致的。

例如，堆内存大小设置过小，无法满足应用程序的需求。

在排查问题时，可以尝试调整内存配置参数，增加堆内存大小或者调整垃圾回收算法等。

通过适当调整内存配置参数，可以有效地缓解或解决OOM内存溢出问题。

6. 优化代码和算法除了修复内存泄漏和调整内存配置参数外，还可以通过优化代码和算法来降低应用程序的内存占用。

例如，可以减少对象的创建和销毁次数，尽量复用对象，避免使用过多的静态变量等。

通过优化代码和算法，可以减少内存占用，提高应用程序的性能和稳定性。

内存泄漏和内存溢出、堆内存和栈内存区分、负载标准、降低cache内存方法

内存泄漏和内存溢出、堆内存和栈内存区分、负载标准、降低cache内存方法

（一）内存泄漏和内存溢出内存溢出 out of memory，是指程序在申请内存时，没有足够的内存空间供其使用，出现out of memory；比如申请了一个integer,但给它存了long才能存下的数，那就是内存溢出。

内存溢出就是你要求分配的内存超出了系统能给你的，系统不能满足需求，于是产生溢出。

内存泄露 memory leak，是指程序在申请内存后，无法释放已申请的内存空间，一次内存泄露危害可以忽略，但内存泄露堆积后果很严重，无论多少内存,迟早会被占光。

内存泄漏是指你向系统申请分配内存进行使用(new)，可是使用完了以后却不归还(delete)，结果你申请到的那块内存你自己也不能再访问（也许你把它的地址给弄丢了），而系统也不能再次将它分配给需要的程序。

memory leak会最终会导致out of memory。

（二）堆内存和栈内存区分一、数据结构中的堆和栈1. 栈是一种连续储存的数据结构，具有先进后出的性质。

通常的操作有入栈（压栈），出栈和栈顶元素。

想要读取栈中的某个元素，就是将其之间的所有元素出栈才能完成。

2. 堆是一种非连续的树形储存数据结构，每个节点有一个值，整棵树是经过排序的。

特点是根结点的值最小（或最大），且根结点的两个子树也是一个堆。

常用来实现优先队列，存取随意。

二、内存中的栈区与堆区1. 内存中的栈区与堆区比较2. 计算机内存的大致划分一般说到内存，指的是计算机的随机存储器（RAM），程序都是在这里面运行。

三、栈内存与栈溢出由程序自动向操作系统申请分配以及回收，速度快，使用方便，但程序员无法控制。

若分配失败，则提示栈溢出错误。

注意，const 局部变量也储存在栈区内，栈区向地址减小的方向增长。

四、堆内存与内存泄露程序员向操作系统申请一块内存，当系统收到程序的申请时，会遍历一个记录空闲内存地址的链表，寻找第一个空间大于所申请空间的堆结点，然后将该结点从空闲结点链表中删除，并将该结点的空间分配给程序。

Android避免内存溢出（OutofMemory）方法总结

Android避免内存溢出（OutofMemory）方法总结

of Memory）方法总Android避免内存溢出（Out结避免内存溢出的方法，主要是对以下三个方面对程序进行优化武汉Android培训内存引用在处理内存引用之前，我们先来复习下什么是强引用、软引用、弱引用、虚引用强引用：强引用是使用最普遍的引用。

如果一个对象具有强引用，那垃圾回收器绝不会回收它。

当内存空间不足，Java 虚拟机宁愿抛出OutOfMemoryError错误，使程序异常终止，也不会靠随意回收具有强引用的对象来解决内存不足的问题。

软引用：如果一个对象只具有软引用，但内存空间足够时，垃圾回收器就不会回收它；直到虚拟机报告内存不够时才会回收，只要垃圾回收器没有回收它，该对象就可以被程序使用。

软引用可用来实现内存敏感的高速缓存。

软引用可以和一个引用队列（ReferenceQueue）联合使用，如果软引用所引用的对象被垃圾回收器回收，Java虚拟机就会把这个软引用加入到与之关联的引用队列中。

弱引用：只具有弱引用的对象拥有更短暂的生命周期。

在垃圾回收器线程扫描它所管辖的内存区域的过程中，一旦发现了只具有弱引用的对象，不管当前内存空间是否足够，都会回收它的内存。

不过，由于垃圾回收器是一个优先级很低的线程，因此不一定会很快发现那些只具有弱引用的对象。

弱引用可以和一个引用队列（ReferenceQueue）联合使用，如果弱引用所引用的对象被垃圾回收，Java虚拟机就会把这个弱引用加入到与之关联的引用队列中。

虚引用：虚引用可以理解为虚设的引用，与其他几种引用都不同，虚引用并不会决定对象的生命周期。

如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收器回收。

虚引用主要用来跟踪对象被垃圾回收器回收的活动。

虚引用与软引用和弱引用的一个区别在于：虚引用必须和引用队列（ReferenceQueue）联合使用。

当垃圾回收器准备回收一个对象时，如果发现它还有虚引用，就会在回收对象的内存之前，把这个虚引用加入到与之关联的引用队列中。

内存溢出的三种情况及系统配置解决方案

内存溢出的三种情况及系统配置解决方案内存溢出是指程序在运行过程中申请的内存超过了系统或者进程所能提供的上限。

导致内存溢出的原因可能是程序中存在内存泄漏、内存分配过多或者递归调用过深等。

下面将介绍三种常见的内存溢出情况及其系统配置解决方案。

1.程序内存泄漏导致内存溢出：内存泄漏指程序在运行过程中动态分配内存空间后，没有对其进行释放，导致一部分内存无法再次使用。

长时间运行的程序中，如果内存泄漏较为严重，系统可用内存会不断减少，直到最终耗尽所有内存资源。

解决方案：使用内存泄漏检测工具来检测和修复程序中的内存泄漏问题。

同时，可以考虑使用自动内存管理的编程语言，如Java和Python，在程序运行过程中自动回收未使用的内存。

2.内存分配过多导致内存溢出：解决方案：优化程序的内存使用，尽可能减小内存分配的数量和大小。

可以通过使用更高效的内存管理算法来减少内存碎片，或者使用内存池技术来提前分配一定量的内存供程序使用。

3.递归调用过深导致内存溢出：递归函数在每次调用时会将一定量的数据压入栈中，如果递归调用层数过深，栈的空间可能会超过系统的限制，从而导致内存溢出。

这种情况通常发生在没有设置递归终止条件或者递归层数过多的情况下。

解决方案：优化递归算法，设置合适的递归终止条件，避免递归调用过深。

如果无法避免使用递归算法，可以考虑使用尾递归或者迭代算法来替代递归调用，减少栈的压力。

在系统配置方面，可以采取以下措施来预防和解决内存溢出问题：1.增加系统内存容量：如果内存溢出是由于系统可用内存不足引起的，可以考虑增加系统的内存容量。

这可以通过增加物理内存条或者使用虚拟内存技术来实现。

虚拟内存技术会将部分磁盘空间用作缓存，并将一部分数据暂时存储在磁盘上，以释放内存空间。

2. 调整JVM参数：对于使用Java虚拟机（JVM）的应用程序，可以通过调整JVM的参数来控制内存的分配和管理。

例如，可以通过设置-Xmx参数来限制JVM使用的最大堆内存大小，或者通过设置-XX:MaxPermSize参数来限制JVM使用的最大持久代（PermGen）内存大小。

电脑开机后出现内存溢出该如何处理

电脑开机后出现内存溢出该如何处理在使用电脑的过程中，我们可能会遇到电脑开机后出现内存溢出的情况。

这是一个让人颇为头疼的问题，不仅会影响电脑的正常运行，还可能导致数据丢失或系统崩溃。

那么，当我们遇到这种情况时，应该如何处理呢？首先，我们需要了解一下什么是内存溢出。

简单来说，内存溢出就是指程序在运行过程中，申请的内存空间超过了系统所能提供的最大内存空间，从而导致程序无法正常运行。

在电脑开机后出现内存溢出，可能是由于多种原因引起的。

一种常见的原因是电脑同时运行的程序过多，占用了大量的内存资源。

比如，我们在开机时自动启动了多个大型软件或进程，这些程序会在后台持续运行，消耗大量的内存。

因此，我们可以检查一下电脑的启动项，关闭一些不必要的自启动程序。

具体操作方法是按下“Ctrl＋ Shift ＋Esc”组合键打开任务管理器，在“启动”选项卡中，禁用那些不需要开机自启的程序。

另外，电脑中存在恶意软件或病毒也可能导致内存溢出。

这些恶意程序可能会在后台偷偷运行，占用大量系统资源。

所以，我们要及时使用杀毒软件对电脑进行全面扫描，清除可能存在的恶意软件和病毒。

同时，要保持杀毒软件的实时更新，以确保能够有效地防御新出现的威胁。

内存不足也是导致内存溢出的一个重要原因。

如果电脑的物理内存本身较小，而我们又在运行一些对内存要求较高的程序，就很容易出现内存溢出的情况。

在这种情况下，我们可以考虑升级电脑的内存。

在购买新的内存之前，需要了解电脑主板支持的内存类型和最大容量，然后选择合适的内存条进行安装。

此外，系统或软件的错误或漏洞也可能引发内存溢出问题。

对于这种情况，我们可以尝试更新系统和相关软件到最新版本。

通常，软件和系统的开发者会在新版本中修复已知的漏洞和错误，从而提高系统的稳定性和兼容性。

除了上述方法，我们还可以通过一些系统设置来优化内存使用。

比如，调整虚拟内存的大小。

虚拟内存是当物理内存不足时，系统从硬盘中划分出的一部分空间作为内存使用。

内存溢出的三种情况及系统配置解决方案

内存溢出的三种情况及系统配置解决方案内存溢出是指程序在运行过程中申请的内存超过了系统所分配的内存空间，导致程序崩溃或出现异常。

内存溢出通常是由于程序设计或系统配置问题引起的。

以下是三种常见的内存溢出情况及相应的系统配置解决方案。

1.单个进程占用内存过大：当一些进程在运行过程中占用的内存超过系统分配的限制时，就会导致内存溢出。

这种情况通常发生在大型应用程序或者后台服务运行时。

解决方案：-增加物理内存：在服务器或计算机中增加物理内存，以满足进程运行所需的内存空间。

-调整虚拟内存：将物理内存和虚拟内存结合使用，允许操作系统使用虚拟内存作为物理内存的扩展，从而提供更大的内存容量。

-优化应用程序：通过优化程序代码、降低内存使用、合理管理资源等方法，减少进程对内存的占用。

2.长时间运行的应用程序产生泄露：有些应用程序在长时间运行后会产生内存泄露的问题，即分配并使用内存后没有将其释放，导致内存占用逐渐增加，最终导致内存溢出。

解决方案：-使用垃圾回收机制：在一些支持垃圾回收的编程语言中，通过垃圾回收机制可以自动释放未使用的内存。

开发人员可以使用这些机制来解决内存泄露问题。

-引入内存监控工具：使用内存监控工具来检测应用程序中的内存泄露，定位并解决导致内存泄露的代码问题。

-定期重启应用程序：定期重启应用程序可以清理内存，防止内存泄露导致内存溢出。

3.大规模并发请求导致内存压力增加：在高并发的情况下，当系统同时处理大量的请求时，每个请求所占用的内存可能累积增加，导致整体内存压力增加，最终出现内存溢出。

解决方案：-加大系统负载均衡能力：通过增加负载均衡器、引入缓存机制等方式，将请求分散到多台服务器上，减少单台服务器的内存压力。

-优化数据库访问：对于一些频繁读写数据库的操作，可以通过合理的数据库设计、使用索引、缓存查询结果等方法，减少对数据库的访问，降低内存压力。

-调整服务器配置：合理设置服务器的最大并发连接数、线程池大小等参数，根据实际需求分配内存资源。

内存泄漏的检测定位和解决经验总结

内存泄漏的检测定位和解决经验总结内存泄漏是指程序在运行过程中，分配的内存没有被正确释放，导致内存资源无法被再次利用的情况。

由于没有及时释放内存，内存泄漏会导致系统的内存消耗不断增加，最终可能造成程序崩溃或者系统运行缓慢。

解决内存泄漏问题需要进行检测、定位和解决。

一、内存泄漏的检测1. 使用内存分析工具：可以使用一些专门的内存分析工具来检测内存泄漏问题，例如Valgrind、Memcheck等。

这些工具可以跟踪程序运行过程中的内存分配和释放，帮助定位内存泄漏的位置。

2.编写测试用例：通过编写一些针对性的测试用例，模拟程序运行过程中常见的内存分配和释放场景，观察内存的使用情况。

如果发现内存占用持续增长或者没有被及时释放，就可以判断存在内存泄漏问题。

3.监控系统资源：通过监控系统的资源使用情况，如内存占用、CPU使用率等，可以观察系统是否存在内存泄漏的迹象。

如果发现系统的内存占用不断增加，并且没有明显的释放情况，就需要进一步检查是否存在内存泄漏。

二、内存泄漏的定位1.使用日志输出：通过在程序中添加日志输出语句，记录程序运行过程中的重要信息，特别是涉及内存分配和释放的地方。

通过观察日志输出，可以发现是否有内存没有被正确释放的情况。

2.代码分析：通过代码分析，找出可能导致内存泄漏的地方。

常见的内存泄漏问题包括：不恰当的内存分配和释放顺序、不正确的内存释放方式、内存分配大小不匹配等。

对于涉及动态分配内存的地方，要特别关注是否有被遗漏的释放操作。

3.堆栈跟踪：当发现内存泄漏问题比较复杂或者难以定位时，可以使用堆栈跟踪来追踪内存分配和释放的调用路径，找出内存泄漏的具体位置。

在调试过程中，可以通过打印调用栈来获取函数调用的过程，进而确定哪个函数没有正确释放内存。

三、内存泄漏的解决1.及时释放内存：在程序中，所有动态分配的内存都需要及时释放。

对于每个内存分配操作，都要确保相应的释放操作存在，并且在适当的时候进行调用。

  1. 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
8. 内存申请不到。1、判断指针是否为 NULL，如果是则马上用 return 语句终止本函数。 Void Func(void) { A *a = new A ; If(NULL == a) { Return ; } …. } B．判断指针是否为 NULL，如果是则马上用 exit(1)终止整个程序的运行。 Void func(void) { A *a = new A ; If (NULL == a) { cout << “memory Exhausted” <<endl ; Exit(1) ; } } C:为 new 和 malloc 设置异常处理函数。 1. Malloc /free 的使用要点 函数原型：void *malloc(size_t size) ; //用 malloc 申请一块长度为 length 的整数 类型的内存。Int *p = (int *) malloc(sizeof(int) *length) ; A:malloc 返回值的类型是 void * ,所以在调用 malloc 时要显式地进行类型转换， 将 void*转换成所需的指针类型。 B:malloc 函数本身并不知道申请内存是什么类型，只关心内存自己总数。
值为 1. 用 delete []objects ;//正确的用法。
总结：1.多用指针。 2.养成逐步调试的习惯。
规则： 用 malloc 或 new 申请内存后，应该立即检查指针是否为 NULL，防止使用指针值为 NULL
的内存。 不要忘记为数组和动态内存赋初值。防止将未被初始化的内存作为右值使用。 避免数组或者指针下标越界，特别当心发生“多 1”或者“少 1“ 动态内存的申请与释放必须配对，防止内存泄漏。 用 free 或 delete 释放了内存之后，立即将指针设置为 NULL，防止产生“野指针”。
Y： Void GetMemory1(char *p, int num) { P = (char *)malloc(sizeof(char) * num) ; } //问题：编译器总是要为函数的每个参数制作临时副本，指针参数 p 的副本上
_p,编译器使 _p = p .如果函数体内的程序修改了_p 的内容，就导致参数 P 的内容作 相应的修改。这就是指针可以用作输出参数的原因。在本例中，_p 申请了新的内 存，只是把_p 所指的内存地址改变了，但是 p 丝毫未变。所以函数 GetMemory 并 不能输出任何东西，事实上，每执行一次 GetMemory 就会泄漏一块内存，因为没 有用 free 释放内存。
指针 Int len = strlen(a);
Char *p = (char *)malloc(sizeof(char) * (len + 1)) ; If(NULL == p)
Return -1 ; Strcpy(p,a) ; // If(strcmpy(p,a) == 0) 3. 指针参数如何传递内存。
6. 野指针，不是 NULL 指针，是指向“垃圾”内存的指针。形成的原因：1、指针变 量没有被初始化。任何指针变量刚刚被创建时不会自动成为 NULL 指针，它的缺省 值是随机的，它会乱指一起。所以，指针变量在创建的同时应当被初始化，要么将 指针设置为 NULL，要么让它指向合法的内存。Char *p = NULL ; char *str =(char *)malloc(100) ;2、指针 P 被 free/delete 之后，没有被指为 NULL，让人误认为 P 是 合法的指针。3.指针操作超越了变量的作用范围。
内存溢出总结： 1. 内存分配未成功，却使用了它。 如果指针 P 是函数的参数，那么在函数的入口处用
assert(p != NULL)进行检查。如果是用 malloc 或 new 来申请内存，应该用 if(p == NULL) 或者 if(P != NULL)来进行防错处理。 2. 内存分配虽然成功，但是尚未初始化就引用它。（犯错的原因：1.没有初始化的观念； 误以为内存的缺省初值全为 0，导致引用初值的错误（如数组））。 3. 内存分配成功并且已经初始化，但操作越过了内存的边界。（数据下标发生“多 1”或 者“少 1”的操作。特别是在 for 循环语句中，循环次数很容易搞错，导致数组越界）。 4. 忘记了释放内存，造成内存泄漏。（含这种错误的函数每次调用就丢失一块内存。刚刚 开始系统的内存充足，可能看不到。但程序突然有一次死掉，系统出现提示：内存耗尽） 动态内存的申请与释放必须配对，程序中 malloc 与 free 的使用次数一定要相同，否则 肯定有错误(new/delete 同理) 5. 释放了内存却继续使用它。一：程序中的对象调用关系过于复杂，实在难以搞清楚某个 对象究竟是否已经释放了内存，此时应该重新设计数据结构，从根本上解决对象管理混 乱局面。二：函数 return 语句写错了，注意不要返回指向“栈内存”的“指针”或者 引用，因为该内存在函数体结束时被自动销毁。三、使用 free 或 delete 释放内存后， 没有将指针设置为 NULL，导致产生“野指针”。
用指向指针的指针后解决这个问题： Void GetMemory2(char **p, int num) {
*p = (char *)malloc(sizeof(char) * num) ; }
用函数返回值了解决： Char *GetMemory3(int num) {
Char *p = (cahr * )malloc(sizeof(char) * num) ; Return p ; } Void Test(void) { Char *str = NULL ; GetMemory1(str, 100);//申请内存错误 GetMemory2(&str, 100) ;//注意参数是&str，而不是 str。 Str = GetMemory3(100) ; Strcpy(str, “hello”); }
7. MAlloc 与 free 是 C/C++语言的标准库函数，new/delete 是 C++的运算符，它们都是 可以用于申请动态内存和释放内存。 对于非内部数据类型的对象而言，光 malloc 和 free 无法满足动态对象的要求。对象在创建的同时要自动执行构造函数，对象 在消亡之前要自动执行析构函数。由于 malloc/free 是库函数而不是运算符，不再 编译器控制的权限之内，不能够把执行构造函数和析构函数的任务强加与 malloc/free。不要企图用 malloc/free 来完成动态对象的内存管理，应该用 new/delete. 由于内部数据类型的”对象”没有构造与析构的过程，对他们而言 malloc/free， new/delete 是等价的。New/delete 的功能完全覆盖了 malloc/free 的功能，保留的 原因是 C++经常需要调用 C 函数，而 c 程序只能用 malloc/free 动态管理内存。如果 用 free 释放“new 创建的动态对象”，那么该对象因无法执行析构函数而可能导致 ：void free(void *memblock) ;指针 p 的类型以及指向的内 存容量事先都知道，所以 free(p)能正确释放内存。如果 P 是 NULL 指针，那么 free 对 P 无论操作多少次都不会出现问题，如果 P 不是 NULL 指针，那么 free 对 P 连续操作两次就会导致程序运行出错。
数组和指针之间区别： 1. 修改内容。
Char a[] = “hello” ; A[0] = ‘X0’ ; Cout << a << endl ;//可以改变常量的值。
Char *p = “world” ; //P 是指向常量的字符串，。 P[0] = ‘X’ ; //error,指针 P 指向常量字符串”world，常量字符串的内容是不可被修改 的” 2. 内容复制与比较。 数组的复制： Char a[] = “hello” ; Char b[10] ; Strcpy(b, a); If (strcmp(b,a) == 0)
4. Free/delete,只是把指针所指的内存释放掉，并没有把指针本身干掉。 5. 函数体内局部变量在函数结束时自动消亡。但是局部指针变量，消亡的时候它所指
的动态内存不一定一起消亡.(比如别的模块调用怎么办)。1、指针消亡了，并不表 示它所指的内存会被自动释放。2、内存被释放了，并不表示指针会消亡或者成了 NULL 指针。
3. New/delete 要点。 Int *p2 = new int[length] ;因为 new 内置 sizeof、类型转换和 类型安全检查功能。对于非内部数据类型的对象而言，new 在创建动态对象的 同时完成了初始化工作。如果对象有多个构造函数，那么 new 的语句也可以 有多种形式。
A：如果用 new 创建对象数组，那么只能使用对象的无参数构造函数。 Obj *objects = new obj[100] ; //创建 100 个动态对象。 不能写成 Obj *objects = new obj[100](1) ;//创建 100 个动态对象同时赋初