HEAP[xxx.exe]:Invalid Address specified to RtlValidateHeap 错误的解决方法总结

转自：http://blog.youkuaiyun.com/chenyujing1234/article/details/8244718

一、情况一

抽象出问题是这样的：

[cpp]  view plain copy

1. class DLL_API1 A  
2. {  
3.     func()  
4.     {  
5.         vector vec;  
6.         B b;  
7.         b.func(vec);  
8.         return TRUE;  
9.     }  
10. }  

 

其中B是另一个导出类，定义如下

[cpp]  view plain copy

1. class DLL_API2 B  
2. {  
3. private:  
4.     vector m_vec;  
5. public:  
6.     func( vector &vec )  
7.     {  
8.         vec = m_vec;  
9.     }  
10. }  

 

运行时发现，每次运行到A的return TRUE释放vector的时候，都会报错：user breakpoint called from code at  xxxxxxxxxxxxx，并在Debug的提示框中出现：

HEAP[xxx.exe]:Invalid Address specified to RtlValidateHeap    的提示。

网上查了下，基本上都是说是dll和exe在不同的地方开辟了空间，在不同的地方释放的问题。看来以后还需要注意呢。

解决的方法是：

是外层被使用的内存，可以在外层定义后传参到非托管函数，在内部赋值后，在外层被调用，然后被释放；在内部被申请的空间，需在内部显式的的释放，避免造成内存泄露，这样就不会出现上述两种错误。（引用自：http://155134558.blog.163.com/blog/static/22278462009727103058451/）

 

也就是说可以做如下修改：

[cpp]  view plain copy

1. class DLL_API1 A  
2. {  
3.     func()  
4.     {  
5.         B b;  
6.         int nCnt = b.func1();  
7.            
8.         vector vec;  
9.         b.func2(vec);  
10.   
11.         return TRUE;  
12.     }  
13. }  
14.   
15.    
16.   
17. class DLL_API2 B  
18. {  
19. private:  
20.     vector m_vec;  
21. public:  
22.     int func1()  
23.     {  
24.         return m_vec.size();  
25.     }  
26.     func2( vector &vec )  
27.     {  
28.         vec = m_vec;  
29.     }  
30. }  

 

不过目前这种解决方案看起来是比较挫啦，不知道能不能从设计上避免。这个问题就先放在这里吧。以后有更多经验的时候再回头看。

二、情况二

遇到该问题的原因是，托管代码和非托管代码之间的分配机制不同，两者之间可以进行互操作，下面是查到的相关内容：

经过一段时间对MSDN的钻研，终于明白C++/CLI互操作共分三种：

1.P/Invoke

2.Com interop

3.C++ interop

我想版主推荐的是指采用C++ interop方式。代码过程如下：

1.将非托管结构和函数放在#pragmaunmanaged内，像这样

[cpp]  view plain copy

1. #pragma unmanaged   
2.   
3. struct cUserNestedStruct   
4.   
5. {  
6.   
7. .........  
8.   
9. } ;  
10.   
11. extern "C" int DllFunction(UserDefinedStruct**);  

2. 然后，在托管代码中就可以直接调用了。

[cpp]  view plain copy

1. #pragma  
2.   
3. managed  
4.   
5. int main()  
6.   
7. {  
8.   
9. UserDefinedStruct*   mystruct = new UserDefinedStruct();  
10.   
11. int num = DLLFunction(&mystruct);  
12.   
13. }  

 

上述是调用Dll，进行互操作的情况。

在我们的项目中，使用托管和非托管混合的方法，通过头文件，直接调用非托管程序。这里需要注意的是：托管代码的内存管理和非托管的内存管理是不同的。在内存堆的分配上也是不同的，所以，两者之间不能直接进行内存的互调用，例如：1，在非托管代码中不能释放托管代码申请的内存；

2，在非托管代码中申请的内存，在函数结束后就被释放，如果被return到托管环境里，是无效的地址。

是外层被使用的内存，可以在外层定义后传参到非托管函数，在内部赋值后，在外层被调用，然后被释放；在内部被申请的空间，需在内部显式的的释放，避免造成内存泄露，这样就不会出现上述两种错误。

本项目中的问题是在非托管代码中，使用了对托管代码中内存块的一个引用，然后在函数结束时，被释放，这样就是free掉了托管代码中申请的内存，会报错，访问无效的内存。

三、情况三

在编译的时候，exe和dll有可能链接的是静态的运行时库，也有可能链接的是dll版本的运行时库。如果在exe或者是dll中有一个链接的是静态的运行时库，那么就会存在两套内存分配的实例。所以在dll中申请的内存，到exe中释放就会失败，因为exe并不认识那块内存。解决的办法就是都使用dll版本的运行时库，这样，在进程空间内，只有一个运行时实例。

 

四、情况四

[cpp]  view plain copy

1. WCHAR aPathname[]=L"\\\\c:\\pbk_temp";  
2. WCHAR aFilename[]=L"100.dat";  
3. DWORD dwLimitedReadSize=0;  
4. unsigned char* content;  
5. content=NULL;  
6.           .......  
7.   
8. dwResult = CONAReadFile(hFS, &FileInfo, content, dwLimitedReadSize, aPathname);  
9.          .........  
10.   
11.   
12. delete [] content;  
13. content=NULL;  

 

 

CONAReadFile是Nokia提供的一个函数，原型为
DWORD CONAReadFile(FSHANDLE hFSHandle, LPCONAPI_FILE_INFO pFileInfo, unsigned char** ppFileData, DWORD dwLimitedReadSize, const WCHAR* pstrTargetPath)

现在我只要一执行delete [] content;程序就崩了。单步跟出现提示信息HEAP[PROPERTYSHEET.exe]: Invalid Address specified to RtlValidateHeap( 00A90000, 00197CC8 )

这是怎么回事？该怎么解决。如果不delete会不会造成内存泄漏。

原因：

在Nokia的库中同时提供了释放char* content的方法，因为char* content指向的内存是由dll中的方法分配的，所以应该由dll中的方法释放。这正好符合C++关于谁分配，谁释放的准侧。
从这个例子，我们可以看到，以后在写dll时，如果在dll中的某个方法内部分配了内存，同时要写一个释放该段内存的方法，对外公开，用来给外部的函数调用

 

五、情况五

我封装了dll 原来是exe 现在封装成dll
发现了这个错误 函数都执行没问题 就是函数执行完 就爆这个错误
我没用dll什么的 就用了string 

调用是

[cpp]  view plain copy

1. void CTestDlg::OnButton1()    
2. {      
3.     // TODO: Add your control notification handler code here       
4.     UpdateData(TRUE);       
5.     string ts = m_text;       
6.     string sData = _ConvertHextoCString(ts);         
7.     AfxMessageBox(sData.c_str());     
8. }   

dll封装函数是

[cpp]  view plain copy

1. #include "stdafx.h"   
2. #include <string>   
3. using namespace std;     
4. BOOL APIENTRY DllMain( HANDLE hModule,   DWORD  ul_reason_for_call, LPVOID lpReserved)   
5. {       
6.     return TRUE;   
7. }   
8. string ConvertHextoString(string hex)   
9. {       
10.     string result;       
11.     char temp[3];       
12.     int i = 0;       
13.     int nLen = hex.length();       
14.     if (nLen%2 != 0)       
15.     {           
16.         return "ERROR";       
17.     }                
18.     return result;  
19. }  

问题解决了 封装dll 最好类型不要用string 这样很容易有问题
还有就是在传入参数 加上const这样 就保证不会有问题了

 

六、情况六

Dll之间由于由于空间分配和删除引起的

invalid address specified to rtlvalidateheap

在外层模块中定义了一个变量，传入内层模块赋值，用完后在外层模块释放时出错。

 

一个可能的原因：

在不同模块（工程）之间传递 C++ 类，而这两个模块用了不同的运行时库（Runtime Library）设置。

例如：EXE 模块调用 DLL 模块里传递 C++ 类的函数，但 DLL 模块使用静态链接（Release 是 Multi-threaded (/MT)、Debug 是 Multi-threaded Debug (/MTd)）方式编译，而 EXE 模块使用动态链接（Release 是 Multi-threaded DLL (/MD)、Debug 是 Multi-threaded Debug DLL (/MDd)）方式编译。

可以对比这两个模块的工程属性 - C/C++ - Code Generation - Runtime Library，看看设置是否一样，如果不一样要改成一样的。

如果无法解决问题，那就是别的原因了。

 

 

七、情况七

析构函数出问题

调试信息：

HEAP[MHPSO.exe]: Invalid Address specified to RtlValidateHeap( 00390000, 00DAAC68 )
Windows 已在 MHPSO.exe 中触发一个断点。

其原因可能是堆被损坏，这说明 MHPSO.exe 中或它所加载的任何 DLL 中有 Bug。

一般是野指针导致。

八、

转载自： http://www.bhcode.net/article/20100713/12048.html

[cpp]  view plain copy

1. //微粒类  
2. class PARTICLE  
3. {  
4. public:  
5.     double *X;      //微粒的坐标数组  
6.     double *V;      //微粒的速度数组  
7.     double *XBest;  //微粒的最好位置数组  
8.     int Dim;        //微粒的维数  
9.     double Fit;     //微粒适合度  
10.     double FitBest; //微粒最好位置适合度  
11.   
12.   
13.     //构造函数  
14.     PARTICLE();     //空构造函数  
15.     PARTICLE(int n);//维数为参数的构造函数  
16.     //析构函数  
17.     ~PARTICLE();  
18.     void SetDim(int d); //设置微粒的维数  
19. };  
20.   
21.   
22.   
23. //微粒构造函数  
24. PARTICLE::PARTICLE() //空构造函数  
25. {  
26.     X = 0; V = 0; XBest = 0; Dim = 0;  
27. }  
28.   
29. PARTICLE::PARTICLE(int n) //维数为参数的构造函数  
30. {  
31.     if(n<0)   
32.     {  
33.         cout<<"输入有错，维数必须大于0"<<endl;  
34.         return;  
35.     }  
36.     Dim = n;  
37.     X = new double[Dim];  
38.     V = new double[Dim];  
39.     XBest = new double[Dim];  
40. }  
41.   
42.   
43. //微粒析构函数  
44. PARTICLE::~PARTICLE()  
45. {  
46.     if(Dim)  
47.     {  
48.         delete X;  
49.         delete V;  
50.         delete XBest;  
51.         X=0;  
52.         V=0;  
53.         XBest=0;  
54.     }  
55. }  
56.   
57.   
58.   
59.   
60. //定义群粒子类  
61. class PSO  
62. {  
63. public:  
64.     PARTICLE * Particle;    //微粒群数组  
65.     int PNum;               //微粒个数  
66.     int GBestIndex;         //最好微粒索引  
67.     double W;               //惯性权重  
68.     double C1;              //加速度系数1  
69.     double C2;              //加速度系数2  
70.     double *Xup;            //微粒坐标上界数组  
71.     double *Xdown;          //微粒坐标下界数组  
72.     double *Vmax;           //微粒最大速度数组  
73.   
74.     void Initialize();      //初始化群体  
75.     void CalFit();          //计算全体适合度  
76.     virtual void ParticleFly(); //微粒飞翔，产生新一代微粒   
77.     //通讯函数，返回值为false时，系统停止优化  
78.     bool (*Com)(double,     //最优微粒适合度  
79.     double*,                //最优微粒坐标数组  
80.     double**,               //所有微粒坐标指针数组  
81.     int);                   //当前最优微粒索引  
82.   
83.   
84.   
85.   
86.     //构造函数  
87.     PSO(); //空构造函数  
88.     PSO(int dim, //微粒维数  
89.     int num); //微粒个数  
90.     //析构函数  
91.     ~PSO();  
92. };  
93.   
94.   
95.   
96. //PSO构造函数  
97. PSO::PSO()  
98. {  
99.     Particle = 0;  
100.     PNum = 0;  
101.     GBestIndex = 0;  
102.     Xup = 0;  
103.     Xdown = 0;  
104.     W = 1;  
105.     C1 = 2;  
106.     C2 = 2;  
107.     Com = 0;  
108. }  
109.   
110.   
111. PSO::PSO(int dim, int num)  
112. {  
113.     if(dim<0 || num <0)   
114.     {  
115.         cout<<"输入有错，维数和粒子个数必须大于0"<<endl;  
116.         return;  
117.     }  
118.   
119.   
120.     Particle = new PARTICLE[num];  
121.     for(int i=0; i< num; i++)   
122.         Particle[i].SetDim(dim);  
123.     PNum = num;  
124.     GBestIndex = 0;  
125.     Xup = new double[dim];  
126.     Xdown = new double[dim];  
127.     Vmax = new double[dim];  
128.     W = 1;  
129.     C1 = 2;  
130.     C2 = 2;  
131.     Com = 0;  
132. }  
133.   
134.   
135.   
136. //析构函数  
137. PSO::~PSO()  
138. {  
139.     if(Particle)   
140.         delete []Particle;  
141.     if(Xup)   
142.         delete []Xup;//位置上界  
143.     if(Xdown)   
144.         delete []Xdown;//位置下界  
145.     if(Vmax)   
146.         delete []Vmax; //速度上下界  
147.     Xup = 0;  
148.     Xdown = 0;  
149.     Vmax = 0;  
150.     Particle=0;  
151. }  
152.   
153.   
154.   
155.   
156.   
157.   
158.   
159.   
160.   
161. //派生多种群分层的PSO类  
162. class MHPSO   
163. {  
164. public:  
165.     PSO** FirstPso; //第一层多种群粒子群的指针的指针  
166.     int L; //第一层种群的个数 = 第二层粒子群中粒子的个数   
167.     double C3; //加速度系数3  
168.     PSO* SecondPso;//第二层的粒子群指针  
169.     HANDLE wMutex;  
170.     double Vmin[20] ; //当粒子飞行速度小于Vmin的时，速度变化已不能更新粒子的位置，重新初始化速度  
171. public:  
172.     MHPSO()  
173.     {  
174.         FirstPso=0; L=0; SecondPso=0; C3 = 2;  
175.         for(int i=0;i<20;i++)  
176.         Vmin[i] = 0.0001 ;  
177.         wMutex = ::CreateMutex(NULL,false,NULL);  
178.     }  
179.   
180. //构造函数，给出微粒维数n 和种群个数L,种群中粒子的个数m  
181. MHPSO(int n, int m,int L)  
182. {  
183.     this->L = L;  
184.     FirstPso = new PSO*[L];  
185.     for(int i=0 ;i< L;i++)  
186.         FirstPso[i] = new PSO(n,m);  
187.   
188.   
189.     SecondPso = new PSO(n,L);   
190.     C3 = 2;  
191.     for(int i=0;i<20;i++)  
192.         Vmin[i] = 0.0001 ;  
193.     wMutex = ::CreateMutex(NULL,false,NULL);  
194. }   
195.   
196.   
197. ~MHPSO()  
198. {  
199.     for(int i=0;i<L;i++)  
200.     {  
201.         delete this->FirstPso[i];  
202.         this->FirstPso[i] =0;  
203.     }  
204.   
205.     delete []FirstPso;  
206.     this->FirstPso = 0;  
207.   
208.     delete SecondPso;   
209.     SecondPso =0; //这两句有问题。。。，如果去掉程序就不会出错。。  
210.     ::CloseHandle(wMutex);  
211. }  
212.   
213. };