Thread: Need Help for New Operator Behaviour

Hi All

I created a program for allocating array of objects dynamically using operator overloading of new Operator. Below is the code. I have not implemented the code for deletion of array of objects as I want to understand the behavior of construction first.

Code:

//OverNew.h

class OverNew
{
  int age;
  std::string name;

public:
	void* operator new(size_t) throw(bad_alloc);
	void* operator new[](size_t) throw(bad_alloc);
	void operator delete(void*);

        OverNew(int,std::string); 
	 void getData();
	 OverNew(int);
	 OverNew();
       ~OverNew();
};

Code:

//OverNew.cpp
#include<iostream>
#include<string>

using namespace std;

#include "OverNew.h"

OverNew::OverNew(int a,string str)
{
	cout <<" \n Inside 2 Parameter Ctr";
    age = a;
	name = str;
}
OverNew::OverNew(int a)
{
   age = a;
   cout << "\n Inside Ctr:"<<age;
}

OverNew::OverNew()
{
   cout << "\n Inside Empty Ctr";
}

void* OverNew::operator new( size_t size) throw(bad_alloc)
{
  
	
	cout << "\n Inside Operator New :"<<size; 
	void *ptr;
	try
	{
	   ptr = malloc(size);
    }
	catch (bad_alloc)
	{
		cout<<"Memory Exception";
	}
	
	return ptr;
}


void* OverNew::operator new[] (size_t size) throw(bad_alloc)
{
  
	
	cout<<"\n Inside Array of New Operator:"<<size;
	return new OverNew(size);
}

void OverNew::operator delete( void *m)
{
	cout<<"\n Inside Overload operator Delete";
	if (!m ) 
		return ;

	free(m);
  
}


OverNew::~OverNew()
{
   cout <<"\n Inside Destructor";
   
}

void OverNew::getData()
{
  cout<<age <<"\t" <<name;

}

int main()
{
 

	OverNew *N = new OverNew[10];

//	 delete N;
	 getchar();
     return 0;
}

When I execute this program: Below is the output:

Inside Array of New Operator:168
Inside Operator New :16
Inside Ctr:168
Inside Empty Ctr
Inside Empty Ctr
Inside Empty Ctr
Inside Empty Ctr
Inside Empty Ctr
Inside Empty Ctr
Inside Empty Ctr
Inside Empty Ctr
Inside Empty Ctr
Inside Empty Ctr

I want to understand that what is this output means:

Inside Array of New Operator:168

So since my class has one integer and one string variable so total sum is 12. Since we are creating array of objects , I am assuming 4 bytes to this pointer which result in total 16 bytes.
So I am creating 10 objects so : 10 * 16 = 160
but it is coming as 168 size. why?

Since I am not passing any parameter, I expect that one parameter constructor should not called. But it is called and also 10 empty constructor too. I want to know for which object, this parameter constructor was called?

Can Any body help me understanding this?

Thanks
Nickman

Thanks Elisa for pointing of those points. I have to put try catch in main from where I am creating objects and bad_alloc will be thrown by operator new.
I have changed that.

Ok I got you point too of cell padding. I forgot to consider that point.

But one question is still want to know. The call for one parameter constructor. Why that constructor called when I am creating zero arguments object.

Thanks
Nickman

Yes. I agree that operator delete[] shoulb be implemented and I mention in post too that I have not implemented that I want to understand the behavior of construction first.

I have changed the implementation and rather that calling:

Code:

void* OverNew::operator new[] (size_t size) throw(bad_alloc)
{
  
	
	cout<<"\n Inside Array of New Operator:"<<size;
	return new OverNew(size);

I am using this:

Code:

void* OverNew::operator new[] (size_t size) throw(bad_alloc)
{
  
	
	cout<<"\n Inside Array of New Operator:"<<size;


    void *ptr;
    ptr = malloc(size);
 	
	return ptr;
}

It's now printing as what I was expecting. Below is whole code.

Code:

#include<iostream>
#include<string>

using namespace std;

#include "OverNew.h"

OverNew::OverNew(int a,string str)
{
	cout <<" \n Inside 2 Parameter Ctr";
    age = a;
	name = str;
}

OverNew::OverNew(int a)
{
   age = a;
   cout << "\n Inside Ctr:"<<age;
}


OverNew::OverNew()
{
   cout << "\n Inside Empty Ctr ";
}



void* OverNew::operator new( size_t size) throw(bad_alloc)
{
  
	
	cout << "\n Inside Operator New :"<<size; 
	void *ptr;
    ptr = malloc(size);
 	
	return ptr;
}


void* OverNew::operator new[] (size_t size) throw(bad_alloc)
{
  
	
	cout<<"\n Inside Array of New Operator:"<<size;
   //	return new OverNew(size);

	void *ptr;
    ptr = malloc(size);
 	
	return ptr;
}

void OverNew::operator delete( void *m)
{
	cout<<"\n Inside Overload operator Delete";
	if (!m ) 
		return ;

	free(m);
  
}


void OverNew::operator delete[]( void *m)
{
   cout<<"\n Inside Overload Array operator Delete";
	
  //  delete(m);


	if (!m ) 
		return ;

	free(m);

}

OverNew::~OverNew()
{
   cout <<"\n Inside Destructor";
   
}

void OverNew::getData()
{
  cout<<age <<"\t" <<name;

}

int main()
{
 
	OverNew *N;
	try
	{
	      N = new OverNew[10]();
	}
	catch (bad_alloc)
	{
		cout<<"Memory Exception";
	}
	
	 delete []N;
	 getchar();
     return 0;
}

Thanks
Nickman