一个很重要的问题－－100分

[My_QQ]

大家可能经常遇到这样的情况
T* p=new T[100000];
如果Delete p当然没问题
但我想只删除其中的一个时该如何办那
因为我不想一个一个的NEW
数据量大，太慢拉！！！

[freshairfly]

T* p=new T[100000];
delete[] p;

for(i = 0; i < 100000; ++i)
{
delete p++;
}

我觉得这样可以delete them one by one
不过如果你选中几个删除后，以后你就不知道哪几个被删除了。

[My_QQ]

朋友，我不是说了，FOR()要一个一个的NEW，太慢了
我连续NEW 400000个30BYTE 的类时，程序就没反映了
指针的指针还可以考虑

[My_QQ]

而且我要尽量减少内存的使用，
一个一个的NEW时，在堆里事实上浪费了好多字节的RAM啊

[My_QQ]

for(i = 0; i < 100000; ++i)
{
delete p++;
}
有问题啊！！想想吧！

[brucegong]

freshairfly(菜鸟精神)
为什么不给每一个指针设置一个标志？

struct Point_Struct
{
BOOL bUse;
T* pPointer;
};

struct Point_Struct p[10000];

for()
{
...
p[i].bUse = TRUE;
...
}


delete的时候置为false或者……或者将指针置空……总之方法太多了

程序员是无所不能的

[brucegong]

在一个那么在意内存的系统里面还用常规方式来new delete？？

奢侈

内存紧张的系统都是自己管理内存的，根本不是用new delete

[My_QQ]

好，你有好办法，
多多指教！

[umbrella1984]

T* p=new T[100000];
delete[] p;

for(i = 0; i < 100000; ++i)
{
delete p++;
}

这里有问题吧？上面已经delete[] p;了怎么下面还delete p++;？

[freshairfly]

T* p=new T[100000];
delete[] p;

for(i = 0; i < 100000; ++i)
{
delete p++;
}

这里有问题吧？上面已经delete[] p;了怎么下面还delete p++;？
-----------------------------------------------------------------
我的意思是两种delete方法。楼主说需要只delete一部分，第二种方法就可以

[darkstar21cn]

for(i = 0; i < 100000; ++i)
{
delete p++;
}
是错误的

[freshairfly]

brucegong(飞行猪)
为什么不给每一个指针设置一个标志？
－－－－－－－－－－－－－－－－－－－－－－－－－－－－
我当然知道这个问题可以解决。

[freshairfly]

for(i = 0; i < 100000; ++i)
{
delete p++;
}
有问题啊！！想想吧！
－－－－－－－－－－－－－－－－－－－－－－－－－－－
有什么问题就说出来，不要装作很高深的样子！！

还有你到底要问的什么问题，怎么一会儿“只删除其中的一个”
一会儿“FOR()要一个一个的NEW，太慢了”
麻烦说清楚，OK？

[daylove]

好象是有点不对，

那个：for( i=0;i < 10000 ; ++i )
{
delete p++;
}

这里可以一个个删除吗？不明白，

楼主也没有必要指定删除某个啊，等你最后不用时，整个delete [] p;不就可以了？？？

[freshairfly]

而且我要尽量减少内存的使用，
一个一个的NEW时，在堆里事实上浪费了好多字节的RAM啊
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
一起new就不会浪费内存了吗？

[freefalcon]

楼主先说清楚需求
为何要一次new这么多对象
为何又要在某个时刻删除一个

[nicknide]

freshairfly(菜鸟精神)：
brucegong(飞行猪)
为什么不给每一个指针设置一个标志？
－－－－－－－－－－－－－－－－－－－－－－－－－－－－
我当然知道这个问题可以解决。

首先，飞行猪啊，你都已经把那个地方删除了，然后还去访问，有可能产生非法访问啊（操作系统把那个空页给回收了，你访问就得到一个致命的调页失败错误，如果没有用SEH，直接程序就DOWN了……

菜鸟精神啊，你还要有认真精神才好，也要想一想再说嘛……

[umbrella1984]

我定义了一个二维数组，怎么循环显示数组值？
for(int ii=0;ii<20;ii++){

a[ii]=new int[ii];


}

for(int iii=0;iii<2;iii++){

for(int iiii=0;iiii<20;iiii++){

cout<<*a[iiii]<<endl;

[My_QQ]

1
关于堆的管理，系统在背后做了很多工作，是它在浪费内存，
你可以查查资料
2
p =new T[];
for( i=0;i < 1 ; ++i )
{
delete p++;
}
时，你的内存应该已经没有了
3 大家有办法的就多多指教，不知道的也多想想
不要把话题扯远了

[brucegong]

kao
伤自尊了……我习惯用free……

[cpunion]

当然是可以解决的，实际上你提到的是一个内存池的概念，一般用来解决数量比较多的小对象的连续分配，这要用到placement new，以下代码仅供参考：

#include <iostream>
#include <string>

using namespace std;

class Test
{
string str;
public:
Test (int n){char buf[20]; snprintf (buf, 20, "%d", n); str = buf; cout << "ctor:" << str << "\t";}
~Test () {cout << "dtor:" << str << "\t";}
};

Test的构造函数接受一个整数，主要是用来输出，也可以用来测试。

int main ()
{
int SIZE = 10000;
void* array = operator new[](SIZE * sizeof(Test)); //分配内存

Test* testArray = static_cast<Test*>(array); //强制转换，

for (int i=50; i<100; i++)
{
new (&testArray[i]) Test(i); //placement new，译成什么我也不知道，实际上就是在已有的堆内存上构造对象，后面的Test(i)是调用构造函数。
}

for (int j=99; j>=70; j--)
{
testArray[j].~Test(); // 因为内存是一起分配的，你无法调用delete来删除某一个，只可以析构。如果调用delete，后果无法预知。
}

//我分成2段循环，是让你看到我以不同的顺序来析构对象，并没有影响到什么。
for (int k=50; k<70; k++)
{
testArray[k].~Test();
}

operator delete[](array); //释放内存
return 0;
}

上面我分配了可以容纳10000个Test的内存，实际上只使用了其中的50个。

testArray[k].~Test();也可以写成testArray[k].Test::~Test();