how do globally defined new/delete operators work?

[johndoe444]

Hi,

#include <iostream>
#include <cstdlib>
#include <new>
using namespace std;
class loc {
                 int longitude, latitude;
public:
                 loc() {}
                 loc(int lg, int lt) {
                 longitude = lg;
                 latitude = lt;
}

void show() {
                cout << longitude << " ";
                cout << latitude << "\n";
}
};
// Global new
void *operator new(size_t size)
{
                void *p;
                p = malloc(size);
                if(!p) {
                                   bad_alloc ba;
                                   throw ba;
                }
                return p;
}
// Global delete
void operator delete(void *p)
{
               free(p);
}

int main()
{
                  loc *p1, *p2;
                  float *f;
                  try {
                              p1 = new loc (10, 20);
                  } catch (bad_alloc xa) {
                              cout << "Allocation error for p1.\n";
                              return 1;;
                  }
                  try {
                              p2 = new loc (-10, -20);
                  } catch (bad_alloc xa) {
                              cout << "Allocation error for p2.\n";
                              return 1;;
                  }
                  try {
                             f = new float; // uses overloaded new, too
                  } catch (bad_alloc xa) {
                             cout << "Allocation error for f.\n";
                             return 1;;
                  }
                  *f = 10.10F;
                  cout << *f << "\n";
                  p1->show();
                  p2->show();
                  delete p1;
                  delete p2;
                  delete f;
                  return 0;
}

I am not completely sure how this mechanism works. Particularly the new operator function works on void* p defined within its body and no parameter to the target class type is passed to the operator function, so how is the constructor to target type is passed the parameters (ie 10, 20)? It seems like magic.

One other thing, when the new operator is called in main, we did not call, sizeof. But for typical situation when malloc is involved we do something like this:

int* p = (int*) malloc(5*sizeof(int));

if we don't use sizeof then only 5 bytes are allocated instead of 5*4(say int is of 4 bytes).

This seems also mysterious.

Does someone care to explain?

Thanks.

f = new float; is normal syntax for the built-in new operator. It has nothing to do with your overloaded new, as you can see if you comment-out that definition. new float allocates memory for a float and returns a pointer to it. It needs no size parameter because the compiler already knows how much memory a float (or an int, or a double, etc) requires.