函数参数中new出来的对象怎么释放？
函数参数中new出来的对象怎么释放？
比如 void fuc（new CEntityString("abcd")，1，5）
{
}
这里的new CEntityString("abcd") 出来的空间还需要释放么？
哪位老大讲一下，分数可能不多，大家笑纳
问题点数：100、回复次数：72Top
1 楼owlling（owlman）回复于 2006-11-21 20:57:21 得分 0
new有两种形式，delete于他对应
以string为例好了
1，string *s = new string("abc");
////
delete s;
2，string *s = new string[100];
////
delete[] s;Top
2 楼yangbc（土豆块）回复于 2006-11-21 21:00:06 得分 0
哦，楼上的意思我知道，我是想问函数参数中的new的空间在内存中是怎么样存在的，由于没有办法调用delete，所以我不知道怎么释放这样的空间？Top
3 楼wanfustudio（雁南飞：知识之败,慕虚名而不务潜修也）回复于 2006-11-21 21:01:45 得分 0
这里的new CEntityString("abcd") 出来的空间还需要释放么？
哪位老大讲一下，分数可能不多，大家笑纳
=================
只要是new的就需要delete
注意保存指针，好回收空间Top
4 楼wanfustudio（雁南飞：知识之败,慕虚名而不务潜修也）回复于 2006-11-21 21:01:58 得分 0
否则内存泄漏Top
5 楼owlling（owlman）回复于 2006-11-21 21:05:37 得分 0
没有办法delete的话，说明已经出现或者必然导致内存泄漏了，永远不能失去heep上空间的句柄啊。一直到被deleteTop
6 楼A_B_C_ABC（黄瓜@YouCanDoIt）回复于 2006-11-21 21:20:41 得分 0
不要在C++中使用Java的编译风格。
CEntityString *pcs=;new CEntityString("abcd");
fuc（p,1,5）;
delete pcs;
Top
7 楼lei001（太极）回复于 2006-11-21 21:31:38 得分 0
c++没有内存垃圾回收的
应该弄个指针保存地址，以便释放申请的空间的Top
8 楼kenneth_lueng（）回复于 2006-11-21 21:59:25 得分 0
没有报错？？？？
相当奇怪，还真不知道c++能在函数定义的时候用这种语法
调用函数用这种语法倒可以，但应该会造成内存的泄漏的Top
9 楼weiym（磨刀霍霍向猪羊）回复于 2006-11-21 22:02:10 得分 0
这样会泄露Top
10 楼chenqing1128（Alex）回复于 2006-11-21 22:32:14 得分 0
可以这样调用的．释放的时候把该参数释放即可．
fuc（new CEntityString("abcd")，1，5）；这个只是一个调用．显然不是定义．比如如果楼主的定义是这个样子
void fuc(CEntityString *p,int i,int j);
那就在fuc函数里释放:delete p;如果把ｐ的值传出来了，实际上传得是那个地址，就释放那个地址．
其实这个ｐ是形参，你delete p实际上是释放ｐ所指向的内容而不是ｐ本身．不会有问题的．
我一直想强调一点的是void fuc(CEntityString *p,int i,int j);中的ｐ是形参，所以对于地址ｐ来讲是传值而不是传指针．但是对于CEntityString 来说就是传指针了．
所以楼上凡是说这种方法不对的都对指针不是太了解．
总之如下几种方式都可释放：
1.
必须确保出了ｆｕｃ后不用这个结构体了CEntityString ；
void fuc(CEntityString *p,int i,int j)
{
//do something
delete p;//必须确保不用这个结构体了CEntityString ；
}
2.如果在ｆｕｃ外面用到比如：
void fuc(CEntityString *p,int i,int j)
{
//do something
//将ｐ加入一个链表
}
那就在释放链表的时候释放．Top
11 楼lann64（昆仑大鹏＠迦楼罗）回复于 2006-11-21 22:44:07 得分 0
void fuc（new CEntityString("abcd")，1，5）
{
}
－－－－－－－－－－－－－－－－－－－－
这里func肯定是错误的，函数调用语法没有这样的，注意后面的{}.函数定义也不能这样用，注意参数，不是变量。Top
12 楼lann64（昆仑大鹏＠迦楼罗）回复于 2006-11-21 22:46:46 得分 0
所有new出来的对象都需要delete，不管是不是用做参数，所有new出来的对象都应该保留指针，以便用来delete，不管是指针参数变量，还是普通指针变量。Top
13 楼yangbc（土豆块）回复于 2006-11-21 22:56:48 得分 0
呵呵，我函数调用写错了，花括号是不要的，lann64(昆仑大鹏＠迦楼罗) 批评的对Top
14 楼argenCHN（【夷不谋夏，胡不乱华】）回复于 2006-11-22 00:02:09 得分 0
用完了就要记得deleteTop
15 楼yangbc（土豆块）回复于 2006-11-22 11:41:29 得分 0
没有人从内存分配的角度讲一下么？Top
16 楼greengrince（踏雪而行）回复于 2006-11-22 11:58:26 得分 0
都是强人Top
17 楼OOPhaisky（异化$渴望成功~~）回复于 2006-11-22 12:14:39 得分 0
void fuc（new CEntityString("abcd")，1，5）
{
}
-------------------------------------------------------------------------------------
这是在定义函数？没有这种定义方法。
如果：
void fuc（CEntityString* temp，1，5）
{
......
delete temp;//此句可以释放内存，避免产生内存泄漏
}
fuc（new CEntityString("abcd")，1，5）;
这样是可以的，即用new构造一个临时对象，然后将指针传递给fuc函数。此时可以在fuc尾部通过delete释放temp指向的内存。但是这里有一个隐含的层面：通过temp传入的指针必须是new分配的，而不能是静态内存区的指针，否则delete的结果未定义。Top
18 楼abblly（西边日出东边雨）回复于 2006-11-22 12:47:04 得分 0
楼主干嘛非要这么做啊，这样的函数，给别人用，别人敢用吗？
void fuc（CEntityString* temp，1，5）
{
......
delete temp;//此句可以释放内存，避免产生内存泄漏
}
直接写]
void fuc（CEntityString* temp，1，5）
{
......
}
在调用之前new
CEntityString* temp = new CEntityString;
fun(temp);
delete岂不更好？不要给自己找麻烦啊
Top
19 楼A_snail（蜗)(牛)VS.(钉)(子）回复于 2006-11-22 12:47:29 得分 0
void fuc（CEntityString* temp，1，5）
{
......
delete temp;//此句可以释放内存，避免产生内存泄漏
}
------------------------------------------------------------------
赞同这种处理方式；
另外，若参数是一个类的话，应该也可以通过调用类的析构函数来释放空间吧...
void fuc（CEntityString* temp，1，5）
{
......
temp->~CEntityString();
}
Top
20 楼chllcy（搬张小板凳,听星星们的高见）回复于 2006-11-22 12:55:52 得分 0
强啊 学习一下Top
21 楼flyfine（城市里的农村人）回复于 2006-11-22 13:35:59 得分 0
我觉得这是一个痞子习惯，首先我不知道你是要写这个函数体呢还是在函数调用。如果是实现函数体的话，那么分配内存的操作为什么不放到函数体中，并且记住该内存地址，以便在函数的最后释放内存。如果是函数调用的话，也最好在调用之前记住申请内存的地址，调用完了之后主动delete掉。 new 总是和delete成对使用的，至少在C＋＋中应该这样。
－－－－－－ 随便说点，高手请批Top
22 楼westdot（子思）回复于 2006-11-22 13:52:43 得分 0
显然在函数定义时里面要有一个delete。
如定义：
void fun(int *p, ...)
{
...
delete p;
}
p只能接受堆内存指针。
在函数调用时new对象也不是第一次接触到了，auto_ptr。。。Top
23 楼w_anthony（）回复于 2006-11-22 14:02:34 得分 0
fuc（&CEntityString("abcd")，1，5);
这样呢？Top
24 楼alan001（星岛孤裔林郎君）回复于 2006-11-22 14:32:29 得分 0
引用不是指针,要删除引用????Top
25 楼todototry（来csdn，学会扯淡了...）回复于 2006-11-22 14:39:24 得分 0
函数参数中new出来的对象怎么释放？
比如 void fuc（new CEntityString("abcd")，1，5）
{
}
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
CEntityString * fuc（ptmp = new CEntityString("abcd")，1，5）
{
......
return ptmp;
}
主调函数记得的释放，
int main()
{
CEntityString * p = fuc（ptmp = new CEntityString("abcd")，1，5）;
delete p;
}
个人意见，高手多多指教Top
26 楼shawnwan（）回复于 2006-11-22 14:57:24 得分 0
void fuc（CEntityString* temp，1，5）
{
......
delete temp;
}
不DELETE是会内存丢失哦，
其实就算头文件内没定义成 （CEntityString* temp，1，5），也可以在实现的地方实现，因为C++，C编译器都没把参数名字当做参数，名字只是给程序员做标记用的。编译器只是根据类型和定义的顺序来进行函数的编译。
所以这里LZ的方法是自己找不到对TEMP内存的描述，当然不能够进行DELETE啦
Top
27 楼w_anthony（）回复于 2006-11-22 15:14:10 得分 0
w_anthony() ----------------------------
fuc（&CEntityString("abcd")，1，5);
这样呢？
alan001(星岛孤裔林郎君)-----------------
引用不是指针,要删除引用????
----------------------------------------
是说我吗？这样写就是把临时对象的地址传进去，根本不用删除，也不会有内存泄露吧！？Top
28 楼Nowish（看我能忍耐多久）回复于 2006-11-22 16:29:22 得分 0
mark~Top
29 楼breakout（）回复于 2006-11-22 16:51:14 得分 0
学习接分Top
30 楼gapwind（）回复于 2006-11-23 14:04:02 得分 0
markTop
31 楼cheqiang（小六子）回复于 2006-11-23 14:48:12 得分 0
可以在CEntityString中的析构函数里面做delete
这样运行期结束，自动会删除了。
Top
32 楼hiox_ppl（ranger）回复于 2006-11-23 15:56:15 得分 0
支持 chenqing1128(Alex)
C++经常忘记delete，造成内存使用量一直上涨
java就没这方面的问题了Top
33 楼sc_0512（angels）回复于 2006-11-23 16:41:35 得分 0
学习Top
34 楼chinatangcy（灵龙）回复于 2006-11-23 17:09:29 得分 0
void fuc（CEntityString* temp，1，5）
{
......
delete temp;
}
的方式是不适宜的。
一般内存申请和释放，应当遵循谁申请谁释放的原则，在调用函数那里申请的空间，应该交给调用函数去释放，不应该在被调用函数中释放，否则可能会
1、使用静态空间，而被释放，发生错误；
2、释放不是本身进程或线程或动态链接库空间的内存造成错误；
3、不同的程序可能由于编译器的差异比如VC和BCB，在空间存储格式上存在差异，释放其他编译器程序生成的空间可能会造成越界访问或内存泄漏。
4、多处使用的空间被某处释放，造成其他被调用函数访问错误；
......
危害多多～Top
35 楼knowall_888（）回复于 2006-11-23 17:27:58 得分 0
CEntityString* temp = new CEntityString("abcd");
void fuc（temp,1,5);
delete temp;
我认为调整程序结构比从代码本身找问题更实际
Top
36 楼zhscnd（无助）回复于 2006-11-23 17:31:11 得分 0
楼上说得对Top
37 楼navyblue1982（这家伙很懒）回复于 2006-11-23 18:10:27 得分 0
void fuc（new CEntityString("abcd")，1，5）
{
string* pstr = &CEntityString;//保留指针
fuc（pstr,1,5);
delete pstr;//删除对象
}
Top
38 楼daoguang8（）回复于 2006-11-23 18:59:40 得分 0
各位好啊,我是一个学C++的新手。遇到一些情况请大家帮帮忙。我建一个头文件一个主文件，但是编译的时候。它提示错误下面是我的代码。我感觉代码没错，但是它提示Cannot open include file: 'head.h': No such file or directory Error executing cl.exe.我也不知道是啥意思请各位大师给指点指点。感激不尽。
//main()
#include <iostream.h>
#include <head.h>
using namespace std;
main()
{int i,j;
cout<<"请输入学号"<<endl;
for(i=0;i<3;i++)
cin>>student[i].num>>endl;
cout<<"请输入姓名"<<endl;
for(i=0;i<3;i++)
cin>>student[i].name>>endl;
cout<<"请输入性别"<<endl;
for(i=0;i<3;i++)
cin>>student[i].sex>>endl;
cout<<"请输入成绩"<<endl;
for(i=0;i<3;i++)
for(j=0;j<3;j++)
cin>>student[i].score[j]>>endl;
cout<<"输出学生数据"<<endl;
for(i=0;i<3;i++)
{cout<<"学号"<<' \t'<<student[i].num<<endl;
cout<<"姓名"<<' \t'<<student[i].name<<endl;
cout<<"性别"<<' \t'<<student[i].sex<<endl;
cout<<"分数"<<' \t'<<endl;
for(j=0;j<3;j++)
cout<<student[j].score[j];
}
}
//head
struct stu
{char num[3];
char name[8];
char sex;
int score[3];
}student[3];
Top
39 楼dw14132124（）回复于 2006-11-23 19:01:44 得分 0
fuc（new CEntityString("abcd")，1，5);
如果这样的函数调用,它在这里生成了临时的一个对象. 它分配了对象所须的空间,然后调用了CEntityString类的构造函数,.它一直作用到函数结束,当函数调用完成时,返回时,生成的这个临时的类会自动被释放．
在这个时候，会调用析构函数，然后释放空间．所以你不必想怎么去释放生成的这个临时对象．Top
40 楼llgdyxmm（）回复于 2006-11-23 21:55:56 得分 0
你的头文件包含格式不对,应该写成
#include <iostream>
#include "head.h"Top
41 楼zenny_chen（ACE Intercessor）回复于 2006-11-23 22:22:46 得分 0
class EntityString
{
public:
EntityString(const char *)
{
}
~EntityString(void) { }
};
void func(EntityString* = new EntityString("abcd"), int = 1, int = 5)
{
}
void main(void)
{
func();
}
在VS2003.NET下的编译结果：
在main()函数中：
func();
00411C23 push 1
00411C25 call operator new (411523h) // 调用new操作符分配空间
00411C2A add esp,4 // 将参数1弹出
00411C2D mov dword ptr [ebp-0D4h],eax
00411C33 mov dword ptr [ebp-4],0
00411C3A cmp dword ptr [ebp-0D4h],0
00411C41 je main+6Bh (411C5Bh)
00411C43 push offset string "abcd" (4270C8h)
00411C48 mov ecx,dword ptr [ebp-0D4h]
00411C4E call EntityString::EntityString (41100Fh) // 这里调用构造函数
00411C53 mov dword ptr [ebp-0E8h],eax
00411C59 jmp main+75h (411C65h)
00411C5B mov dword ptr [ebp-0E8h],0
00411C65 mov eax,dword ptr [ebp-0E8h]
00411C6B mov dword ptr [ebp-0E0h],eax
00411C71 mov dword ptr [ebp-4],0FFFFFFFFh
00411C78 push 5
00411C7A push 1
00411C7C mov ecx,dword ptr [ebp-0E0h]
00411C82 push ecx
00411C83 call func (4113A2h) // 调用func函数
00411C88 add esp,0Ch
}
00411C8B xor eax,eax
00411C8D mov ecx,dword ptr [ebp-0Ch]
00411C90 mov dword ptr fs:[0],ecx
在main()函数中没有调用EntityString的析构函数。
在func()函数中：
void func(EntityString* = new EntityString("abcd"), int = 1, int = 5)
{
00411BC0 push ebp
00411BC1 mov ebp,esp
00411BC3 sub esp,0C0h
00411BC9 push ebx
00411BCA push esi
00411BCB push edi
00411BCC lea edi,[ebp-0C0h]
00411BD2 mov ecx,30h
00411BD7 mov eax,0CCCCCCCCh
00411BDC rep stos dword ptr [edi]
}
没做任何事情。
因此内存没被释放。
Top
42 楼zenny_chen（ACE Intercessor）回复于 2006-11-23 22:29:09 得分 0
另外，chinatangcy(灵龙) 说得不错。应当注意一下程序设计的思想和逻辑。
『一般内存申请和释放，应当遵循谁申请谁释放的原则』
所以，既然楼主提出了问题，我们当然应该尽量去想办法帮他解决。
上面我提供了可通过编译运行的程序原型，现在利用该原型对本问题进行解决：（很简单）
void main(void)
{
EntityString *temp = new EntityString("abcd");
if(temp == NULL)
return;
func(temp);
delete temp;
}Top
43 楼zenny_chen（ACE Intercessor）回复于 2006-11-23 22:30:32 得分 0
上面的例子可以利用显式地传递参数来覆盖掉原本的默认参数。从而得到良好的运行结果。Top
44 楼wskyo（呆呆虫）回复于 2006-11-24 08:45:47 得分 0
强,学习Top
45 楼ikiki（她来听我的演唱会）回复于 2006-11-24 08:50:00 得分 0
楼住的这个函数就像一个劣质的电热水器，好可怕。Top
46 楼Elysium（東鱗覀爫）回复于 2006-11-24 10:02:15 得分 0
头条？Top
47 楼itcsayid（）回复于 2006-11-24 10:29:15 得分 0
楼主是想要嵌套么？Top
48 楼malligator（十步之内没有我的爱人）回复于 2006-11-24 10:39:00 得分 0
可以在函数内释放吧Top
49 楼yzcurry（什么都不会）回复于 2006-11-24 10:51:03 得分 0
deleteTop
50 楼liufengping（）回复于 2006-11-24 12:07:56 得分 0
这里new出来的空间当然是需要释放的,要不就是内存泄露了,在函数内构造对象是可以的但是你需要在返回这个构造对象的指针，做好记录，然后适当的时候释放掉它，这种方式一般也是用的比较多的，比如在一个系统中，某个对象（CDog)在系统运行到一定状态是往往需要分派出一个副本常常的做法就是如下申明
CDog* CDog::Clone()
{
CDog* pDog = new CDog;
//code
return pDog;
}
外部释放如下
CDog myDog;
CDog* pCloneDog = myDog.Clone(); //创建副本
delete pCloneDog; //释放副本
如果函数有CDog*形参，就和你的情况是一样的，总之你的函数返回结果应该是new对象的指针
CDog* CDog::Clone( new CDog())
{
//code
return pDog;
}
Top
51 楼moontornado（）回复于 2006-11-24 16:10:17 得分 0
void fuc（new CEntityString("abcd")，1，5）
{
}
这事应该让bill gates解决
让visual studio支持这种结构！！！Top
52 楼daiyong_79（口笛）回复于 2006-11-24 16:25:08 得分 0
.......这个new出来的东东怎么调用......匿名的哎.....Top
53 楼Aaron_Jerry（音乐诗人）回复于 2006-11-24 16:29:14 得分 0
当个总结者把.呵呵
1.有new必有delete,她俩就像是一对连体双胞胎不可分割.
2.作为函数调用的参数,肯定会有一个指针来保存这个动态对象的,或者在函数内delete这个指针,或者在函数外delete "等价"指针. 注:"等价"指针是指在处理过程中也指向那个动态对象的.
3.尽量不要这样写,尤其是在工作过程中.要注意代码的安全性,可读性.Top
54 楼camzhang（猪）回复于 2006-11-24 16:34:58 得分 0
bill gates也很难解决这个问题，因为对象存在一个生命周期的问题，要编译平台来判断生命周期不可想象，倒是没有研究过JAVA是怎么做的Top
55 楼eplanet（[翅膀]）回复于 2006-11-24 16:57:29 得分 0
这么写的话，就要配合良好的算法设计了。
如果根本无法确认new出来的东东的正确的生存周期。那就想办法记录下指针，然后退出程序的时候一起放掉。
也就是同一管理这些空间。Top
56 楼zenny_chen（ACE Intercessor）回复于 2006-11-24 21:09:18 得分 0
其实，对于：
class EntityString
{
public:
EntityString(const char *)
{
}
~EntityString(void) { }
};
void func(EntityString* = new EntityString("abcd"), int = 1, int = 5)
{
}
最简单的做法是：
void main(void)
{
func(NULL); // 不用担心内存泄漏了^_^
}Top
57 楼rickerliang（专回0分贴(来交流不是为分)）回复于 2006-11-24 23:01:40 得分 0
笑死我勒～～～～～Top
58 楼mfktsall（）回复于 2006-11-24 23:31:47 得分 0
都是高手~~学习一下!Top
59 楼mfktsall（）回复于 2006-11-24 23:47:41 得分 0
新手上路,,在家教下哈,,在哪发问题啊???
Top
60 楼axx1611（long long *&ago）回复于 2006-11-25 00:42:41 得分 0
楼主到底想问什么我还是搞不清楚。不过对于这种写法，并不是一定那么危险和没用，关键是用的人自己得清楚内存到底分配到哪里了，举个例子：
class PStrStack
{
public:
PStrStack() {}
virtual ~PStrStack();
void Push(const string &szNew);
void Push(string *pszNew = new string("abcd"));
private:
vector<string *> m_vecStr;
};
PStrStack::~PStrStack()
{
vector<string *>::const_iterator i = m_vecStr.begin();
for (; i < m_vecStr.end(); i++)
delete *i; // 析构释放string对象空间
}
void PStrStack::Push(const string &szNew)
{
m_vecStr.push_back(new string(szNew)); // 此时string对象空间是由PStrStack分配的
}
void PStrStack::Push(string *pszNew)
{
m_vecStr.push_back(pszNew); // string对象空间由外部分配
}
int main()
{
PStrStack *p = new PStrStack;
p->Push("1234");
p->Push();
string *pStr = new string("try");
p->Push(pStr); // pStr的内存移交给p所指PStrStack对象管理
pStr = NULL; // 避免意外情况，可以先将这个指针置空（根据需要决定）
p->Push(new string("xyz"));
delete p;
return 0;
}
绝不能
string *pStr = new string("string");
p->Push(pStr);
...
delete pStr;
delete p;
这样pStr的空间等于是被delete了两次。。。
Top
61 楼happyCore（）回复于 2006-11-25 11:37:33 得分 0
楼上的。。真是不知道楼主在说什么哇。。Top
62 楼cradmin（）回复于 2006-11-25 13:03:49 得分 0
to dw14132124()
______________________________
fuc（new CEntityString("abcd")，1，5);
如果这样的函数调用,它在这里生成了临时的一个对象. 它分配了对象所须的空间,然后调用了CEntityString类的构造函数,.它一直作用到函数结束,当函数调用完成时,返回时,生成的这个临时的类会自动被释放．
在这个时候，会调用析构函数，然后释放空间．所以你不必想怎么去释放生成的这个临时对象．
——————————————————————————————————————————
我试了一下，由new生成得对象在其生命周期结束时并没有自动调用对象的析构函数，另外即使在显式调用比如CEntityString的析构函数后，由new申请的那块内存也没有什么变化（应该内存没释放），只有调用delete后那块内存发生了变化（在vc里面看了一下那个地址的内存，改了几个字节，不知道干什了什么），同时还调用了对象CEntityString的析构函数，new和delete应该是成对使用的
想问一下大家，delete时到底做了些什么？
另外 to zenny_chen(ACE Intercessor)：
void func(EntityString* = new EntityString("abcd"), int = 1, int = 5)
{
}Top
63 楼cradmin（）回复于 2006-11-25 13:04:30 得分 0
不好意思，上面没说完
void main(void)
{
func();
}
想问一下，像这种调用是main函数还是func函数负责调用new来生成的对象，这两者有什么区别吗（是不是在那释放都一样）
我也是新手，不对的地方大家指点！Top
64 楼jiajiaedu（两会）回复于 2006-11-25 15:44:14 得分 0
编译没通过.Top
65 楼wqf363（denny）回复于 2006-11-25 17:03:14 得分 0
new出来的都保存在进程的全局堆里，只有自己delete或者给别的对象delete，一定要delete，否则肯定内存leakTop
66 楼zhaolei254（）回复于 2006-11-25 22:45:03 得分 0
长见识了!我正在学c++ 学了相当多的东西Top
67 楼zenny_chen（ACE Intercessor）回复于 2006-11-25 22:50:38 得分 0
To cradmin() :
两者并没有本质上的区别。new操作返回的是动态分配的存储片的首地址，因此在delete时也要用它作为参数。你也可以将new所返回的地址视为memory handleTop
68 楼shendl（良少）回复于 2006-11-26 00:25:02 得分 0
void fuc（new CEntityString("abcd")，1，5）
{
}
===================================================================
这个函数写得不对。 第一个参数，应该是一个指针，或者对象引用。
new CEntityString("abcd")应该在调用代码中使用。 再在调用代码中释放。不应该在函数中释 放外部生成的对象。否则必然出现错误！
void fuc（CEntityString* temp，1，5）
{
......
delete temp;//此句可以释放内存，避免产生内存泄漏
}
上面这种写法，也是绝对错误的！ 会释放已经释放的对象，造成错误！
Top
69 楼arrowcy（长弓手）回复于 2006-11-26 00:48:16 得分 0
我怎么记得在某个地方见到过这种用法，好像是msdn？反正我也就的这种用法有问题，一直没这么用。Top
70 楼keily（）回复于 2006-11-26 16:42:28 得分 0
真郁闷！~Top
71 楼xu_yuanjie（）回复于 2006-11-26 18:14:59 得分 0
怎么能这样写呢，到时候谁来释放呢？Top
72 楼missilery（导弹专家）回复于 2006-11-26 20:47:41 得分 0
void fuc（new CEntityString("abcd")，1，5）
{
}
这个就不叫做函数了吧
估计可以这样
void fuc(CEntityString * s = new CEntityString("abcd"),int b=1,float c=2)
{
delete s;
}Top
