new有两种形式，delete于他对应
以string为例好了
1，string *s = new string("abc");
////
delete s;
2，string *s = new string[100];
////
delete[] s;

哦，楼上的意思我知道，我是想问函数参数中的new的空间在内存中是怎么样存在的，由于没有办法调用delete，所以我不知道怎么释放这样的空间？

这里的new CEntityString("abcd") 出来的空间还需要释放么？
哪位老大讲一下，分数可能不多，大家笑纳
=================
只要是new的就需要delete

注意保存指针，好回收空间

否则内存泄漏

没有办法delete的话，说明已经出现或者必然导致内存泄漏了，永远不能失去heep上空间的句柄啊。一直到被delete

不要在C++中使用Java的编译风格。

CEntityString *pcs=;new CEntityString("abcd");
fuc（p,1,5）;
delete pcs;

c++没有内存垃圾回收的
应该弄个指针保存地址，以便释放申请的空间的

没有报错？？？？
相当奇怪，还真不知道c++能在函数定义的时候用这种语法

调用函数用这种语法倒可以，但应该会造成内存的泄漏的

这样会泄露

可以这样调用的．释放的时候把该参数释放即可．
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
    //将ｐ加入一个链表
}
那就在释放链表的时候释放．

void fuc（new CEntityString("abcd")，1，5）
     {

      }
－－－－－－－－－－－－－－－－－－－－
这里func肯定是错误的，函数调用语法没有这样的，注意后面的{}.函数定义也不能这样用，注意参数，不是变量。

所有new出来的对象都需要delete，不管是不是用做参数，所有new出来的对象都应该保留指针，以便用来delete，不管是指针参数变量，还是普通指针变量。

呵呵，我函数调用写错了，花括号是不要的，lann64(昆仑大鹏＠迦楼罗) 批评的对

用完了就要记得delete

没有人从内存分配的角度讲一下么？

都是强人

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的结果未定义。

楼主干嘛非要这么做啊，这样的函数，给别人用，别人敢用吗？

void fuc（CEntityString* temp，1，5）
{
......
delete temp;//此句可以释放内存，避免产生内存泄漏
}

直接写]
void fuc（CEntityString* temp，1，5）
{
......
}

在调用之前new
CEntityString* temp = new CEntityString;
fun(temp);
delete岂不更好？不要给自己找麻烦啊

void fuc（CEntityString* temp，1，5）
{
......
delete temp;//此句可以释放内存，避免产生内存泄漏
}
------------------------------------------------------------------
赞同这种处理方式；

另外，若参数是一个类的话，应该也可以通过调用类的析构函数来释放空间吧...

void fuc（CEntityString* temp，1，5）
{
......
 temp->~CEntityString(); 

}

强啊  学习一下

我觉得这是一个痞子习惯，首先我不知道你是要写这个函数体呢还是在函数调用。如果是实现函数体的话，那么分配内存的操作为什么不放到函数体中，并且记住该内存地址，以便在函数的最后释放内存。如果是函数调用的话，也最好在调用之前记住申请内存的地址，调用完了之后主动delete掉。 new 总是和delete成对使用的，至少在C＋＋中应该这样。
                                            －－－－－－ 随便说点，高手请批

显然在函数定义时里面要有一个delete。
如定义：
void fun(int *p, ...)
{
   ...
   delete p;
}
p只能接受堆内存指针。
在函数调用时new对象也不是第一次接触到了，auto_ptr。。。

fuc（&CEntityString("abcd")，1，5);

这样呢？

引用不是指针,要删除引用????

函数参数中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;
}
个人意见，高手多多指教

void fuc（CEntityString* temp，1，5）
{
......
delete temp;
}
不DELETE是会内存丢失哦，
其实就算头文件内没定义成 （CEntityString* temp，1，5），也可以在实现的地方实现，因为C++，C编译器都没把参数名字当做参数，名字只是给程序员做标记用的。编译器只是根据类型和定义的顺序来进行函数的编译。
所以这里LZ的方法是自己找不到对TEMP内存的描述，当然不能够进行DELETE啦

w_anthony() ----------------------------
fuc（&CEntityString("abcd")，1，5);

这样呢？

alan001(星岛孤裔林郎君)-----------------

引用不是指针,要删除引用????

----------------------------------------

是说我吗？这样写就是把临时对象的地址传进去，根本不用删除，也不会有内存泄露吧！？

mark~

学习接分

mark

可以在CEntityString中的析构函数里面做delete

这样运行期结束，自动会删除了。

支持 chenqing1128(Alex)

C++经常忘记delete，造成内存使用量一直上涨
java就没这方面的问题了

学习

void fuc（CEntityString* temp，1，5）
{
......
delete temp;
}
的方式是不适宜的。
一般内存申请和释放，应当遵循谁申请谁释放的原则，在调用函数那里申请的空间，应该交给调用函数去释放，不应该在被调用函数中释放，否则可能会
1、使用静态空间，而被释放，发生错误；
2、释放不是本身进程或线程或动态链接库空间的内存造成错误；
3、不同的程序可能由于编译器的差异比如VC和BCB，在空间存储格式上存在差异，释放其他编译器程序生成的空间可能会造成越界访问或内存泄漏。
4、多处使用的空间被某处释放，造成其他被调用函数访问错误；
......
危害多多～

CEntityString* temp = new CEntityString("abcd");
void fuc（temp,1,5);
delete temp;
我认为调整程序结构比从代码本身找问题更实际

楼上说得对

void fuc（new CEntityString("abcd")，1，5）
     {
        string* pstr = &CEntityString;//保留指针 
         fuc（pstr,1,5);
          delete pstr;//删除对象 

 }

各位好啊,我是一个学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];

fuc（new CEntityString("abcd")，1，5);


如果这样的函数调用,它在这里生成了临时的一个对象. 它分配了对象所须的空间,然后调用了CEntityString类的构造函数,.它一直作用到函数结束,当函数调用完成时,返回时,生成的这个临时的类会自动被释放．
在这个时候，会调用析构函数，然后释放空间．所以你不必想怎么去释放生成的这个临时对象．

你的头文件包含格式不对,应该写成
#include <iostream>
#include "head.h"

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] 

}

没做任何事情。
因此内存没被释放。

另外，chinatangcy(灵龙) 说得不错。应当注意一下程序设计的思想和逻辑。

『一般内存申请和释放，应当遵循谁申请谁释放的原则』

所以，既然楼主提出了问题，我们当然应该尽量去想办法帮他解决。

上面我提供了可通过编译运行的程序原型，现在利用该原型对本问题进行解决：（很简单）
void main(void)
{
    EntityString *temp = new EntityString("abcd");

    if(temp == NULL)
        return;

    func(temp);

    delete temp;
}

上面的例子可以利用显式地传递参数来覆盖掉原本的默认参数。从而得到良好的运行结果。

强,学习

楼住的这个函数就像一个劣质的电热水器，好可怕。

头条？

楼主是想要嵌套么？

可以在函数内释放吧

delete

这里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;
}