数组指针delete导致程序core down的问题

[woodball]

我如下定义了一个数组类型：
typedef char TNodeType[50];

使用的时候是这样的：
在类中声明为类变量：
TNodeType *m_nodelist;
类的一个方法体中如下分配内存：
m_nodelist = new TNodeType[num] ;//num由函数参数指定

在类的析构函数中对其释放内存：
if(m_nodelist != NULL)
{
delete []m_nodelist;
m_nodelist = NULL;
}

这样在单用户调用服务程序的时候，没有任何问题，但是，一旦多用户并发的时候，服务程序就有可能在delete这句时core down（每个用户拥有自己的对象，这段里不存在互斥的问题）。
请问：我这种使用方法有什么问题？应该如何修改？

[healer_kx]

我觉得你的代码给的不够。

[woodball]

明白意思就行了，代码几十个文件。
我这样处理这个指针数组有问题吗？

[healer_kx]

不是单用户没有问题吗？ 那就没有为难题呗，我看也是没有问题啊。
所以问题不在你这几行代码上吧？

[woodball]

上面说错了，应该改为：
我这样处理这个数组指针有问题吗？

[v2002750]

没什么问题把，我似乎也写过这样的代码

[czp_opensource]

老兄,问题有很多啊!
首先,你试试这样定义一个字符数组:TNodeType str = "hello world";
可以吧???
问题就在这了.
你的TNodeType* str;是什么? str是一个二级指针.delete [] p是释放数组用的.我不明白你单用户的时候为什么能好用??
如果错了,请指正.
没错!!给分!

[jixingzhong]

m_nodelist = new TNodeType[num] ;

这么分配是错误的

[jixingzhong]

if(m_nodelist != NULL)
{
delete []m_nodelist;
m_nodelist = NULL;
}

m_nodelist 在定义后，即是没有分配内存也不是 NULL，
也就是说，在这个类对象没有调用 new 所在的方法就被析构的情况下，
delete 也是要被执行的，
自然很容易就 core down ...

[jixingzhong]

typedef char TNodeType[50];

使用的时候是这样的：
在类中声明为类变量：
TNodeType *m_nodelist;
类的一个方法体中如下分配内存：
m_nodelist = new TNodeType[num] ;//num由函数参数指定
＝＝＝＝＝＝＝＝＝＝＝＝
不要用这个 typedef ...

你的数组是多维的？
那么请从高维开始，一级一级的分配其内存...

我都有些糊涂了 ...
m_nodelist = new TNodeType[num] ; ......

[仰望星空WU]

typedef char TNodeType[50];
m_nodelist = new TNodeType[num] ;//num由函数参数指定
太怪异了

[a_b_c_abc6]

从下面的测试看,你的指针处理没有错误:

int num=4;
typedef char TNodeType[50];
TNodeType *m_nodelist = new TNodeType[num] ;//
cout<<m_nodelist<<endl;

for(int i=0;i<num;++i)
for(int j=0;j<50;j++)
m_nodelist[i][j]=0;

//m_nodelist[3][50]=0;//因为到这里才越界访问,可以肯定这个二维数组是分配成功了的.
//只要你这中间的操作没有越界,delete不应出错.
if(m_nodelist != NULL)
{
delete []m_nodelist;
m_nodelist = NULL;
}
TNodeType *m_nodelist2 = new TNodeType[num] ;
//m_nodelist如果成功析构,那么m_nodelist2的分配和m_nodelist是重合的.
cout<<m_nodelist2<<endl;

[haifeng85]

从下面的测试看,你的指针处理没有错误:

int num=4;
typedef char TNodeType[50];
TNodeType *m_nodelist = new TNodeType[num] ;//
cout<<m_nodelist<<endl;

for(int i=0;i<num;++i)
for(int j=0;j<50;j++)
m_nodelist[i][j]=0;

//m_nodelist[3][50]=0;//因为到这里才越界访问,可以肯定这个二维数组是分配成功了的.
//只要你这中间的操作没有越界,delete不应出错.
if(m_nodelist != NULL)
{
delete []m_nodelist;
m_nodelist = NULL;
}
TNodeType *m_nodelist2 = new TNodeType[num] ;
//m_nodelist如果成功析构,那么m_nodelist2的分配和m_nodelist是重合的.
cout<<m_nodelist2<<endl;


其中：
for(int i=0;i<num;++i)
for(int j=0;j<50;j++)
m_nodelist[i][j]=0;

要改成：
for(int j=0;j<50;j++)
for(int i=0;i<num;++i)
m_nodelist[i][j]=0;
吧！

[a_b_c_abc6]

TO haifeng85()


typedef char TNodeType[50];
TNodeType *m_nodelist = new TNodeType[num] ;//

它这个相当于char nodelist[num][50];
所以我的for循环没有错.
for(int i=0;i<num;++i)
for(int j=0;j<50;j++)//这里是第一维的大小
m_nodelist[i][j]=0;

[woodball]

多谢各位，虽然有人的说法是错误的，我今天蹲坑的时候想到了这个问题的解决方法，去试了后发现了很奇怪的问题。我上面写的几段代码本身没有问题，确实问题出在其他部分。

我所说的m_nodelist是在一个被调用的类中声明并分配内存空间的，这个被调用的类是在服务端程序启动时建立了这个类的对象，这个对象会一直保持到服务端程序终止为止，这里的设计是一个SINGLETON的设计模式，为了说明方便，我们叫它对象a.正因为这样，对象a的类的析构函数对类成员m_nodelist的delete是没有意义的，因此我们在外部类b中声明了指针m_list接收这个数组指针，它实际指向m_nodelist所分配的内存空间，为了消除内存泄露就需要在外部类b的析构函数中delete []m_list这个数组指针。单用户做的时候是没有问题的，因为它new一次就delete一次，是顺序的，多用户调用的时候会出现同时对m_nodelist分配内存的情况，本来正常的话也不应该有问题，但是根据我的调试，奇怪的是，多用户调用对象a的方法给m_nodelist分配了同一块内存地址，当然这样的情况不是每次都这样，而是多用户并发会导致这样的可能。这样在对分配的内存作delete操作的时候会出现这样的情况：第一个用户delete了第二个用户得到的内存空间，而在第二个用户再次delete的时候core down。这就是这个问题的由来。不知道我说明白了没有。

我们分析后觉得都挺奇怪的，就算两个用户调同一个对象的方法给这个对象的一个成员分配内存的时候按常理看也不应该得到相同的地址空间啊！C++语言的内部处理怎么会这样呢？一个类在实例化成对象后难道保留了一块固定大小的内存空间给对象？如果是这样，那就算我们在外部类不释放其分配的内存也不会导致内存泄露了。但是事实却是发生了内存泄露。这里存在一个矛盾，我对C++内部实现机制还不是很清楚，有了解这个问题的大虾，能否给点意见？

[woodball]

等待高人给意见。下周结贴！