Mismatch free() / delete / delete []
at 0x4006895: operator delete(void*) (vg_replace_malloc.c:480)
by 0x8EA6D11: corefunction.
I supect that it is expect me to write free() instead of delete p1.
Given the the code.
I have the structure.
struct Pack
{
unsigned int A;
unsigned int B;
unsigned int c;
unsigned int D;
}
int corefunction()
{
Pack *p1=new Pack;
I filled the value for the p1 object.
I called a virtual funcion by passing the p1 like this
Send((void*)p1); //
if(p1)
delete p1; // Here is the place where i have the doubt that wheher is it expecting to deallocate with free().
return 0;
}
bool Send(void* &get_SendData)
{
sendNextLevel(get_SendData )
}
char* sendNextLevel(void* data)
{
dataLen = sizeof(PackedSysTime);
Pack* txData = NULL;
txData = (Pack*)data;
}
since we have converted void pointer to struct without new operator like c-style casting, does it expecting us to write free while we deallocate the memory
.It is void * &. It's legacy and huge code . So I have written in simple way to understand. But this the flow .
I feel tha i may need to use static cast to convert void pointer to structure.
Please give me suggestions on what could be the issue for mismatch delete
To repeat: There is nothing wrong in the code you posted. There might be things wrong in the code you didn't post, but how would I ever know? I can only make wild guesses.
Wild guess #1: "void * &" is a really weird type. The only reason I can think of to do that, is if Send() is designed to alter the value of p1 in main itself. Print its integer value, before and after, to cerr or stderr to make sure it's not being changed. Feeding a mangled pointer into delete can cause an error like that.
Wild guess #2: You say "you called a virtual function by passing p1 like this", but Pack is a structure with no member functions, virtual or otherwise: It is completely normal and proper to typecast it to (void *). So where does this virtual thing enter the equation? If your structure is actually something completely different, please tell me now.
You actually can't typecast things in the way you show in your example, which leaves me more and more curious to what you're actually doing.
That it's passed as a * & gives it the ability to reach in and mangle p1 itself - the pointer.
What I mean is this:
#include <iostream>
using namespace std;
void mangle_pointer(char * & x) {
// Set the pointer to a blatantly wrong value
x = (char *)123456789;
}
int main(void) {
char *mem=new char;
cerr << "mem is " << (unsigned long)mem << endl;
mangle_pointer(mem);
cerr << "mem is now "<< (unsigned long)mem <<
" and will crash when deleted" << endl;
delete mem; // Deleting any value that you didn't get from new is bad
}
This is a trivial example. Tracking down memory crashes is usually a lot harder, the crash is generally a side-effect of an overrun which stomped on the values of your variables or some important hidden values inside the heap itself. An overrun can leap straight through rational boundaries and stomp on whatever happens to be next to it in memory, with no regard for the line order of your program. If the overrun happened to something in a local variable, this can corrupt other local variables, or corrupt your return vector and cause a crash next time you return from any function. If it happened in the heap, it can corrupt other things you have stored in the heap, or corrupt the heap itself, causing delete to mess up in strange ways the next time you delete anything.
This is to say, "delete myvariable" crashing often has nothing to do with "myvariable". Debris can land far away from an explosion.
First ,I thank you for your time to resolve my question
In your code except mangle_pointer everything is right.Based in the below now can you please tell why do i get mismatch delete in the valgrind report. It didn't pointing to line no but pointing to function name.
---------- Post updated at 12:58 PM ---------- Previous update was at 08:58 AM ----------
Now I suspect that is p1 getting the void pointer as a result of called function(Send)?
Inside the Send function get_SendData is assigned with NULL value.
while Send function come to calling function, will this have Null pointer value in the object(p1).
If p1 is void pointer , will this delete p1 work fine?
I am not sure about how to deallocate the void pointer?Despite being searched in the internet ,I still didn't get the clear answer
void main()
{
struct Pack
{
unsigned int A;
unsigned int B;
unsigned int c;
unsigned int D;
}
Pack *p1=new Pack;
Send((void*)p1);
// After calling Send function, what will be the value of p1 pointer . Is it a null pointer since it is asssigned by null poiner in the called function?
if(p1)
delete p1; // Here is the place where i have the doubt that wheher is it expecting to deallocate with free().
return 0;
}
bool Send(void* &get_SendData)
{
sendNextLevel(get_SendData)
char* _ucDataCmdReply;
_ucDataCmdReply = new char[length];
get_SendData = (void*)_ucDataCmdReply // Here get_SendData is assigned with void pointer
}
char* sendNextLevel(void* data)
{
dataLen = sizeof(PackedSysTime);
Pack* txData = NULL;
txData = (Pack*)data;
}
I have already detailed a large number of wild guesses about why it might be.
Yes, that would do it. That would ruin the value of p1 in main.
"On two occasions I have been asked, 'Pray, Mr. Babbage, if you put into the machine wrong figures, will the right answers come out?' I am not able rightly to apprehend the kind of confusion of ideas that could provoke such a question." --Charles Babbage
You don't. You'll have to save the pointer somewhere else, so that send() doesn't mangle it.
Copying a pointer doesn't do anything weird to the memory being pointed to. A pointer is, more or less, nothing but an integer, its value is the only thing that matters to delete.
void *p2=(void *)p1;
send(p2); // p2 is mangled, p1 is okay
delete p1;