c++ malloc and free object creation and deletion - c++

Question

I will first post my test program in C++ :
#include <iostream>
using namespace std;
class X
{
int x;
public:
X()
{
cout<<"constructing\n";
x=0;
}
int& getx()
{
return x;
}
~X()
{
cout<<"destroying\n";
}
};
int main()
{
X* p=(X*)malloc(sizeof(X));
++p->getx();
p->getx()*=5;
cout<<p->getx();
free(p);
return 0;
}
Output :
5
Now before anyone complains why i used malloc & free in a C++ program, I would like to reiterate that it is just a test program and the above could have been done even with operator new & operator delete. But my questions still remain the same that are:
Even though no object of X is created using malloc or operator new how can we access the class X's variable x ?
Clearly free & operator delete also do not destroy the objects and perform mere dallocations. What would happen if I create an object with new but use operator delete or free instead of delete ? Would my object still be there & will it be still usable ?

Answer 1

If you deallocate an object created with new by calling free(), you are deep into undefined behavior. Likewise, if you deallocate a malloc()'ed object with delete, you have undefined behavior. Whatever you do, never mix the two.
malloc() has different semantics than new: malloc() just allocates the memory, it does not call a constructor. new does the allocation, and also calls the appropriate constructor.
Likewise, there is the analogue difference between free() and delete: delete calls the destructor before freeing the memory, free() does not.
You can use malloc() in C++ to back a true C++ object, but you will have to do the constructor/destructor calls yourself:
//The placement-new below needs this:
#include <new>
//This is what new does:
char* temp = (char*)malloc(sizeof(Foo)); //allocation only
Foo* foo = new(temp) Foo(); //placement-new: construction only
//This is what delete does:
foo->~Foo(); //destruction only
free((void*)foo); //deallocation only
Note that the placement-new syntax in the second line is the only way to explicitly call a constructor in C++. The destructor can be called explicitly just like any other member. The reason for this asymmetry is that the object really is a valid object before destruction, which is not the case before construction.
To your question about why p->getx() compiles. That comes down to this little cast in your code:
X* p=(X*)malloc(sizeof(X));
^
|
this little cast
Here you, the programmer, are explicitly telling the compiler: "I know that the value I'm giving you does not look like a pointer to X, but I tell you that it is. So, stupid compiler, just shut up about the type mismatch, and treat it as a pointer to X anyway, because I, the human, your god, told you so!"
So what can your compiler do? It shuts up about the type mismatch, and treats the pointer as a pointer to X, as you told it. If that's wrong, that's your problem. Maybe the program will run fine anyway, maybe it crashes, maybe it silently corrupts data, maybe a pink elephant appears. Your compiler won't care. It's only care is that it did your wish. Compilers can be very obedient.

Answer 2

Answering this part of the question: "What would happen if I create an object with new but use operator delete or free instead of delete ? Would my object still be there & will it be still usable ?"
Allocating with malloc and freeing with delete is undefined behavior. There is no guarantee that the implementation will use C's free after calling the object's destructor.
Likewise the opposite. If you allocate with new, there is no guarantee that the returned pointer came from an internally called malloc, realloc or calloc, only cases that it would be safe to pass the pointer to free.
Even if it works, it may break the program and/or leak resources, because you would either skip object's constructor or destructor.
EDIT:
You said "Clearly free & operator delete also do not destroy the objects and perform mere dallocations." Well, that is wrong. delete will call object's destructor, so it will destroy and then deallocate.
As for the clarified question in comments, for "why can you still access x", well, malloc will allocate the full space occupied by the object (which, in your case, I believe to be just the x variable), and the variable will be there, only the constructor will not be called, so, its value will not be set to zero. If it was initially zero when you ran the program, it was merely a coincidence.

Answer 3

Reading so many points from so many I myself wrote a program to explain your problem. See below :-
#include <iostream>
#include <vector>
using namespace std;
class X
{
int x;
vector<int> v;
public:
X()
{
cout<<"constructing\n";
x=0;
v.push_back(1);
v.push_back(2);
}
int& getx()
{
return x;
}
vector<int>& getv()
{
return v;
}
~X()
{
cout<<"destroying\n";
}
};
int main()
{
X* p=(X*)operator new(sizeof(X));
++p->getx();
p->getx()*=5;
cout<<p->getx()<<"\n";
for (int x:p->getv())
cout<<x<<" ";
cout<<"\nexecuted\n";
operator delete(p);
return 0;
}
/* Output :-
5
executed
*/
See how p ignored the vector v and went for the line executed. This is because vector<int> being a class (or more precisely a class template) was never created by operator new (or malloc in your case). Your program showed the output for x because it is a primitive type & not a class. For a class you need a constructor & hence operator new or malloc aren't suitable for classes & hence the output. If you simply replace operator new with new & operator delete with delete then the output will be :-
constructing
5
1 2
executed
destroying
Now your code gives the correct & apt results ! Congo !
For your second question, NEVER MIX UP malloc & free with new & delete as it creates UB with not so happening results.