Question

1) I have some static classes in my project that allocate variables within their constructors.

class StaticClass
{
public:
    char *var;
    StaticClass()
    {
        var=new char[100];
    }
};
static StaticClass staticClass;

2) I have overridden the new and delete operators and made them keep track of all current allocations in a std::unordered_map

unordered_map<void*,size_t> allocations;

void* operator new[](size_t size)
{
    void *p=malloc(size); 
    if (p==0) // did malloc succeed?
        throw std::bad_alloc(); // ANSI/ISO compliant behavior
    allocations[p]=size;
    return p;
}

When my program starts, staticClass’s constructor is called before allocations’ constructor is, so operator new() tries to insert size into allocations before it has been initialized, which errors.

Previously, when I ran into problems with the order of static construction, I simply made the std::map into a NULL pointer, and then initialized it the first time it was used, ensuring it would be valid the first time I inserted it:

unsorted_map<void*,size_t> *allocations=NULL;

//in code called by static constructor:
if(allocations==NULL)
    allocations=new unsortedmap()
//now safe to insert into allocations

However, this will no longer work since I would be calling new within operator new(), creating an infinite recursive loop.

I am aware that I could probably solve this by making another special version of operator new that takes some token argument to differentiate it, and just use that to initialize allocations, however in a more general (learning) sense, I would prefer to somehow either

a) force allocations to initialize before StaticClass does (best)

b) have some way to call the default operator new instead of my overridden one (which I don’t think is possible, but…)

c) some other more general solution?

Answer 1

A simple way to avoid initialization order issues is to wrap your static object inside a function:

unordered_map<void*,size_t> &allocations()
{
  static unordered_map<void*,size_t> static_map;
  return static_map;
}

Then use it like this:

void* operator new[](size_t size)
{
    void *p=malloc(size); 
    if (p==0) // did malloc succeed?
        throw std::bad_alloc(); // ANSI/ISO compliant behavior
    allocations()[p]=size;
    return p;
}

However, you still run the risk of std::unordered_map using your operator new internally.