I don't understand the working of placement new and how to free the memory

Question

Allocated some memory-

buf = new char[sizeof(student_rec)*5];//student_rec is class

Then create an array of class 'student_rec' using placement new.

student_rec *sr1;
sr1 = new(buf)student_rec[5];

Call the method fun() for each class.

for(i=0; i<5; i++)
{
    sr1[i].fun();
}

And after that call the destructor for each class.

i = 5;
while(i)
    sr1[--i].~student_rec();

And delete the allocated memory chunk using delete.

delete [] buf;

Then why after that using sr1[2].fun() it prints 'hello' ? When i delete the memory using delete [] buf then there is no memory present for object. Then why sr1[2] works fine ?

Here is my code-

class student_rec
{
    private:

       string name;
       int roll_no;
       float percentage;

    public:

       student_rec()
       {
           cout<<"zero argument constructure\n";
       }

       ~student_rec()
       {
           cout<<"destructure\n";
       }

       student_rec(char *n, int r, float per)
       {
           cout<<"three argument constructure\n";
           name  = n;
           roll_no = r;
           percentage = per;
       }

       void show()
       {
           cout<<"Name= "<<name<<endl;
           cout<<"Roll No.= "<<roll_no<<endl;
           cout<<"Percentage= "<<percentage<<endl;
       }

       void fun()
       {
           cout<<"hello\n";
       }

};

int main()
{
   char *buf;
   buf = new char[sizeof(student_rec)*5];
   student_rec *sr1;
   sr1 = new(buf)student_rec[5];
   int i;
   for(i=0; i<5; i++)
   {
       sr1[i].fun();
   }
   i = 5;
   while(i)
       sr1[--i].~student_rec();
   delete [] buf;
   sr1[2].fun();
   return 0;
}

Answer 1

As the comments already mentioned: What you do is "Undefined Behaviour".

But for your special case, your function fun() did not access any data member of your class and is also not a virtual method, so nothing from your object will be used and so it works quite perfect, also if you will clear your memory, because there is really nothing in the objects memory, what is needed to call this function. As this, you can make this method a static one which then can be accessed without a object of that class.

The compiler knows the type of your pointer student_rec and it also knows that there is no access to any object so it will call simply the method without any data access in your allocated and freed memory.

The following code will also work but is also undefined behaviour:

class Bla
{
    public:
        void fun() { std::cout << "Hallo" << std::endl; }
};

int main()
{
    Bla* ptr=0;

    ptr->fun(); // access of 0 pointer? No-> no data access, simply function call! But never do that in real code ;)
}

The method is from the logic point of view part of the class and not of the objects. As you can see, we never create an instance of the class but the code will also work in most cases.

On gcc 6.1 it compiles and works also with -O0, so it is not dependent on optimization at all. No object data access, so it works without object. But remember: This is perfect invalid code! :-)

Edit: From the comments: Why valgrind did not catch such errors?

Quite simple: If we look into the details of what a compiler makes from a method, we get something like that: ( pseudo code! )

class Bla { void fun() { ... } };

is translated internally to:

Bla::fun( Bla* this ) { ... }

Dependent on the implementation of the compiler, typically the first function parameter is the pointer to the object itself. So the call of fun() results in calling Bla::fun( this ); At this point, it is fully independent of the value of this! So if, as given in my above code example, this is 0! And inside Bla::fun() nothing access the this pointer. So the code seems to be valid!

Valgrind itself checks only on the executable itself, so valgrind will not find an invalid access of data members because it simply find no access which is valid at all :-)

"if this works, what is the difference with static functions?"

If the method is defined as static, the compiler generates a function without the this pointer. So it is different.

"And how are we ever going to trace such errors?"

If your method is not static but did not access any data member, it is a design flaw. I can't see a reason why we should have a method without access to the objects data at all which is not declared static.

My advice here is, to check if you have such non static methods? But yes, I did not know if any compiler can generate a warning on such methods.