March 17, 2015

Example of New operator overloading,Call by value function and reference in c++

Example of New operator overloading in c++

 const int maxnames = 5;  
 class Names  
 {  
 char name[25];  
 static char Names::pool[];  
 static short int Names::inuse[maxnames];  
 public:  
 Names(char* s = 0)  
 {  
 if (s)  
 strncpy(name, s, sizeof(name));  
 }  
 void* operator new[](size_t) throw(std::bad_alloc);  
 void operator delete[](void*) throw();  
 void display() const  
 {  
 std::cout << name << std::endl;  
 }  
 }; // Simple memory pool to handle fixed number of Names. char Names::pool[maxnames * sizeof(Names)];  
 short int Names::inuse[maxnames]; // Overloaded new[] operator for the Names class. void* Names::operator new[](size_t size) throw(std::bad_alloc)  
 {  
 int elements = size / sizeof(Names);  
  // Find the first empty element (if any).  
 int p = -1;  
 int i = 0;  
 while ((i < maxnames) && (p == -1))  
 {  
  if (!inuse[i]) p = i; ++i; } // Not enough room.  
 if ((p == -1) || ((maxnames - p) < elements))  
 throw std::bad_alloc(); // Mark the elements as used.  
  for (int x=0; x inuse[p+x] = elements;  
 // Return pointer to memory.  
 return pool+p*sizeof(Names);  
 } // Overloaded delete[] operator for the Names class.  
 void Names::operator delete[](void* b) throw()  
  {  
  if (b != 0)  
 {  
 int p = ((char*)b - pool) / sizeof(Names);  
 int elements = inuse[p];  
 for (int i = 0; i < elements; i++)  
 inuse[p + i] = 0;  
 }  
 }  
 int main()  
  {  
 Names* np = new Names[maxnames];  
  int i;  
 for (i = 0; i < maxnames; i++)  
 {  
  std::cout << std::endl << "Enter name # " << i+1 << ": ";  
 char name[25];  
 std::cin >> name;  
 *(np + i) = name;  
 }  
 for (i = 0; i < maxnames; i++)  
  (np + i)->display();  
 delete [] np;  
 return 0;  
 }  
 //A call-by-value function and reference in c++  
 struct bigone  
 {  
 int serno;  
 char text[1000];  
 };  
 // Two function prototypes with a structure parameter.  
 void slowfunc(bigone p1); // Call by value.  
 void fastfunc(bigone& p1); // Call by reference.  
 // The main() function.  
 int main()  
 {  
 static bigone bo = {123, "This is a BIG structure"};  
 // This call will take a while.  
 slowfunc(bo);  
 // This call will be faster than the previous one.  
 fastfunc(bo);  
 return 0;  
 }  
 // A call-by-value function.  
 void slowfunc(bigone p1)  
 {  
 }  
 ; }