为什么要动态分配内存？

不明白为什么函数中要动态分配内存，因为要有如下对应关系：
malloc（）和free（）
或者
new 和 delete   /   new [] 和delete[]

在函数里面完全没有必要用这些动态分配吧，比如有如下函数：

void testMethod（）{
      int iArray[5]；//声明一个10元素int数组
      for（int i=0； i<5; i++）
          iArray[i] = 10*i;//for循环使iArray数组内数值为0，10，20，30，40，50
      /*
         ..........
      */
}
上面的方法声明了int数组iArray，并且可以正常使用。
但是，如果用动态内存分配的话，就要这样做：
void testMethod（）{
      int *pInt = new int[5]；//返回一个动态分配的指向int数组的指针pInt
      for（int i=0； i<5; i++）{
          *pInt = 10*i；
          pInt ++；
      }//通过for循环使动态分配的Int数组内容为0，10，20，30，40，50
      pInt = pInt - 5；//重新指向开始分配的初始地址
      delete [] pInt；//释放动态分配的内存
      pInt = NULL；//避免pInt成为野指针
          
      /*
         ..........
      */
}
通过上面的对比，我们在函数中完全可以用int iArray[5] 或者 int i=0；
等这样声明和使用变量，为什么要用new和delete来动态分配呢？
岂不是自找麻烦吗？
动态分配有释放等等操作，稍不注意就会出错。
动态内存分配有什么好处吗，值得我们去使用？
请大家踊跃发言。

56 个解决方案

#1

来个简单的：不动态分配如何动态确定数组大小？

#2

动态分配便于动态删除，呵呵

#3

也来一个： 一个object很大，栈放不下，如何

#4

这就是C/C++的优点也是缺点。

#5

要理解动态两字的含义，动态代表了不确定性。

#6

引用 4 楼 luciferisnotsatan 的回复:

这就是C/C++的优点也是缺点。

如果是C++的话，用STL很方便。

#7

引用 2 楼 loaden 的回复:

动态分配便于动态删除，呵呵

分配了以后肯定要删除啊，但是为什么要动态呢？
就像我说的int i=0； 这个变量在函数执行完也就自动被删除了吧。
难道动态分配仅仅为了“早”删除一会？

#8

引用 4 楼 luciferisnotsatan 的回复:

这就是C/C++的优点也是缺点。

回答了也相当于没有回答。
呵呵，开玩笑的，谢谢。

#9

引用 3 楼 majy 的回复:

也来一个： 一个object很大，栈放不下，如何

能具体举一下例子吗兄弟？

#10

void testMethod(int cnt)
{
	int iArray[cnt]； //声明一个10元素int数组
	for (int i = 0； i < cnt; i++)
		iArray[i] = 10 * i; //for循环使iArray数组内数值为0，10，20，30，40，50
	/*
	..........
	*/
}

void testMethod(int cnt)
{
	int *pInt = new int[cnt]; //返回一个动态分配的指向int数组的指针pInt
	for (int i = 0; i < cnt; i++)
	{
		*pInt = 10 * i;
		pInt ++;
	} //通过for循环使动态分配的Int数组内容为0，10，20，30，40，50
	pInt = pInt - cnt; //重新指向开始分配的初始地址
	delete [] pInt; //释放动态分配的内存
	pInt = NULL; //避免pInt成为野指针
	/*
	..........
	*/
}

#11

有些时候，你根本不清楚你即将处理的数据有多大，你用来缓存的内存够用吗。

举个例子，C风格的字符串跟STL的 string，那个好用，不用多说。
为何好用，就是你用前者，如果不自己动态分配内存，就要写死一个MAX，这个MAX过大，浪费内存，太小，很有可能在某次处理的时候不够用。

#12

数组要是明确知道要使用的内存容量，那使用起来的确很方便！
动态内存分配就是为了内存浪费而设计的！

#13

举个简单的例子，你是要把你这辈子要吃的盐巴全部买下来，还是说你的盐巴什么时候不够了再去买？
你能确定你这辈子吃多少盐巴吗？
当然你可以估计出来，也可能估计的差不多，但是你肯定不会这么做，合理的方法是，随用随买，我是这么理解的，呵呵

#14

等你学了数据结构就知道了

#15

引用楼主 qingzi_wei 的回复:

不明白为什么函数中要动态分配内存，因为要有如下对应关系：
malloc（）和free（）
或者
new 和 delete   /   new [] 和delete[]

在函数里面完全没有必要用这些动态分配吧，比如有如下函数：

void testMethod（）{
int iArray[5]；//声明一个10元素int数组
for（int i=0； i<5; i++）
iAr……

知道吗？所以内存都是动态分配的，时间早晚而已。
动态分配内存有着更大的灵活性，这是优点。
比如，某缓冲区未知大小，需要运行时确定，试问不用动态分配你怎么办？

#16

栈才有2兆大小，不动态，如果超过两兆，就不灵了

#17

引用 9 楼 qingzi_wei 的回复:

引用 3 楼 majy 的回复:
也来一个： 一个object很大，栈放不下，如何


能具体举一下例子吗兄弟？

double too_large[1024*1024];

#18

一是受栈空间的限制,你可以试试
char test[1024*1024]
二就是尽量不浪费和得到想要的内存;
现在的内存很大了的PC上,如果单片机另算,那么动态分配大内存了不能得不到的

#19

顶。。

引用 13 楼 beyondyangkai 的回复:

举个简单的例子，你是要把你这辈子要吃的盐巴全部买下来，还是说你的盐巴什么时候不够了再去买？
你能确定你这辈子吃多少盐巴吗？
当然你可以估计出来，也可能估计的差不多，但是你肯定不会这么做，合理的方法是，随用随买，我是这么理解的，呵呵

#20

继续顶。。。

引用 11 楼 hairetz 的回复:

有些时候，你根本不清楚你即将处理的数据有多大，你用来缓存的内存够用吗。

举个例子，C风格的字符串跟STL的 string，那个好用，不用多说。
为何好用，就是你用前者，如果不自己动态分配内存，就要写死一个MAX，这个MAX过大，浪费内存，太小，很有可能在某次处理的时候不够用。

#21

1 静态分派：是在栈上分配，是由用户自己申请，是由操作系统自己释放的
  动态分配：是由编译器分配，操作系统没有提供这种机制，所以自己申请，必须自己删除！


这上面的呢必须要理解》》》》》》》《《《

2 你也要明白，栈的容量非常的小，而且特别贵，不能满足所有的内存申请，所以就要动态分配，

3 动态分配是编译器自己完成的，跟操作系统没有关系

4 动态分配效率比较低，不过容量跟用户需求有关

#22

如果已知要用的空间不大且大小是预知的范围内，直接用栈就好了。用堆可以申请4G的内存空间，一般的栈也就2M，而且一不小心就会面对栈溢出的问题。

#23

假设需要完成这样一个任务：
从某个文件中读取若干个整数，将它们排序， 输出到另一个文件。


我们不知道“若干个”到底是多少个， 可能是几个， 也可能是几万个，几百万个，几千万个……
楼主打算怎么做呢？

#24

合理管理内存

#25

首要要弄清楚 堆和栈的区别：
栈是线程相关的  一个线程会建立一个栈，函数中的局部变量 实际上是在栈里面的  函数返回后 就从栈中pop出来，栈的容量是有限的  超过一定大小就栈就会击穿了，比如你写了深层次的递归，然后再函数中使用大量的数组，很容易就击穿了
堆是动态存储空间，一个进程默认只有一个堆，进程中所有的线程都共享这个堆的空间，所以你在一个线程中从堆中分配内存，再另一个线程中也可以访问，同时堆也更容易扩展和交换数据

#26

当你不知道数组的大小时，需要动态分配！

#27

引用 21 楼 guandq2106 的回复:

3 动态分配是编译器自己完成的，跟操作系统没有关系

那倒未必，很多情况下都是调用操作系统的API来实现。

#28

动态的还是好用些，很多时候只需改动指针的指向。用多了就习惯了！

#29

引用 11 楼 hairetz 的回复:

有些时候，你根本不清楚你即将处理的数据有多大，你用来缓存的内存够用吗。

举个例子，C风格的字符串跟STL的 string，那个好用，不用多说。
为何好用，就是你用前者，如果不自己动态分配内存，就要写死一个MAX，这个MAX过大，浪费内存，太小，很有可能在某次处理的时候不够用。

同意

#30

为了便于程序运行前不确定所需内存大小的内存分配。

#31

对于要处理的数据我们常常会不知道到底有多大，所以采用动态开辟的方法，这样才可以更加合理的对数据进行处理

#32

数组和动态分配是两个相对的东西,在处理数据变化较小时,可以设定一个数组上限,前提是待处理的数据不能超过这个上限,这个时候用数组是较好的.但如果数量变化较大而又无法确定数据上限到底有多大时,这个时候最好是用动态分配,不然的话,就像前面人提到如果使用一个数组的话,太小了可能会溢出,太大了又有可能会浪费.
如果用到递归,最好尽量避免用局部数组,如果一定要用数组的话,那最好改为static类型的数组.

#33

动态的东西由你掌控，给程序员很大使用的*空间。

#34

你的那个不动态分配的那个，放在栈中，是局部的，如果你要用全局的呢或两个程序要共享变量呢等等，很多东西都要用的！！如果没有动态的话，太糟糕了！！！！

#35

过来学习一下。顺便问下。数组的逻辑结构跟存储结构是不是都一样的。。

#36

引用 35 楼 clear0000 的回复:

过来学习一下。顺便问下。数组的逻辑结构跟存储结构是不是都一样的。。

===========
肯定会有所不一样的

#37

在一些简单的小程序里，动态分配看不出优势来，但是在一些大程序里，有很多的不确定的变量，如果不用动态分配的话，工作量是很大，还造成资源浪废，要知道在电脑里资源是很缺的

#38

对一个对象的操作，特别是大小未知的时候，常用动态分配。

#39

还没入门的问题

#40

动态分配是必免两个指针指向一个地址的其中一种手段

#41

简单一点，你写个链表能不动态分配？
动态分配就是基于现实考虑，在需要时才分配你需要数量的内存（当然你申请的内存什么时候用完，只有你才知道，系统不会浪费时间给你猜的）。
一般的静态变量都是放在栈里（按顺序排列好，访问也最快，当然在回收前是不能改变顺序和已分配的数量的，作用域结束就回收）。

#42

不用解释，过几天他自己就明白了

#43

对，看多了，编多了就会明白了

#44

不知道数组的长度的时候，就需要动态分配.

#45

引用 13 楼 beyondyangkai 的回复:

举个简单的例子，你是要把你这辈子要吃的盐巴全部买下来，还是说你的盐巴什么时候不够了再去买？
你能确定你这辈子吃多少盐巴吗？
当然你可以估计出来，也可能估计的差不多，但是你肯定不会这么做，合理的方法是，随用随买，我是这么理解的，呵呵

这个比喻我喜欢

#46

虽然是由于对象大小的不确定性 貌似导致动态分配很有必要，但我认为最主要原因应该是栈太小的限制。
特别是对于进程本身不大，但是可能操作很大的数据时，就可以使用动态分配内存处理数据，二栈就安排很小但够用就可以 了。

#47

引用 42 楼 heshe 的回复:

不用解释，过几天他自己就明白了

不能这样说，实际上任何事情慢慢都会搞清楚，如果都如您所说，还需要论坛干什么呢？

#48

栈不够用的时候；代码编写时无法确定使用的内存大小的时候，都要用动态内存管理。

#49

因为要运行的所有应用程序在各自的生命周期内所需的内存的总和大于虚拟内存的最大值。

#50

能够管理内存，虽然麻烦但是实用