new and delete operator overloading

Question

I am writing a simple program to understand the new and delete operator overloading. How is the size parameter passed into the new operator?

For reference, here is my code:

#include<iostream>
#include<stdlib.h>
#include<malloc.h>
using namespace std;

class loc{
    private:
        int longitude,latitude;
    public:
        loc(){
            longitude = latitude = 0;
        }
        loc(int lg,int lt){
            longitude -= lg;
            latitude -= lt;
        }
        void show(){
            cout << "longitude" << endl;
            cout << "latitude" << endl;
        }
        void* operator new(size_t size);
        void operator delete(void* p);
        void* operator new[](size_t size);
        void operator delete[](void* p);
};

void* loc :: operator new(size_t size){
    void* p;
    cout << "In overloaded new" << endl;
    p = malloc(size);
    cout << "size :" << size << endl;
    if(!p){
        bad_alloc ba;
        throw ba;
    }
    return p;
}

void loc :: operator delete(void* p){
    cout << "In delete operator" << endl;   
    free(p);
}

void* loc :: operator new[](size_t size){
    void* p;
    cout << "In overloaded new[]" << endl;
    p = malloc(size);
    cout << "size :" << size << endl;
    if(!p){
        bad_alloc ba;
        throw ba;
    }
    return p;
}

void loc :: operator delete[](void* p){
    cout << "In delete operator - array" << endl;   
    free(p);
}

int main(){
    loc *p1,*p2;
    int i;
    cout << "sizeof(loc)" << sizeof(loc) << endl;
    try{
        p1 = new loc(10,20);
    }
    catch (bad_alloc ba){
        cout << "Allocation error for p1" << endl;
        return 1;
    }
    try{
        p2 = new loc[10];
    }
    catch(bad_alloc ba){
        cout << "Allocation error for p2" << endl;
        return 1;
    }
    p1->show();
    for(i = 0;i < 10;i++){
        p2[i].show();
    }
    delete p1;
    delete[] p2;
    return 0;
}

Answer 1

When you write an expression like new loc , the compiler has static type information that lets it know how large a loc object is. Therefore, it can generate code that passes sizeof loc into loc::operator new . When creating an array, the compiler can similar determine how much space is needed to hold all the objects in the array by multiplying the array size by sizeof loc , and then also providing some additional amount of space (determined in an implementation-defined way) that it will use internally to store information about the number of elements in the array.

Hope this helps!