operator new overloading and template functions

**krappa** · 05-22-2008

I'm trying to make a templated version of a memory pool.
The nicest way to do this, would be to overload the new operator, allowing me to give the memory pool as a parameter of the operator.

Here is my current code:

Code:

template <class T>
inline void* operator new(size_t size, MemoryPool& rPool)
{
  return rPool.Allocate<T>(size);
}

This compiles, but I can't find a syntax to call the templated new. Maybe there isn't any...
There might another way to get type information inside the operator new definition...

**matsp** · 05-22-2008

I believe you use a version of placement new, something like:

Code:

sometype *p = new (pool) sometype;

--
Mats

**krappa** · 05-22-2008

Originally Posted by matsp

I believe you use a version of placement new, something like:

Code:

sometype *p = new (pool) sometype;

That works only in the non-templated case. If the new operator and MemoryPool::Allocate don't use templates, this works like a charm.
If I use the templated version and call:

Code:

sometype *p = new (pool) sometype;

I get

Code:

error: no matching function for call to 'operator new(long unsigned int, MemoryPool&)'

I've tried:

Code:

sometype *p = new (pool) <sometype> sometype;

//and

sometype *p = new <sometype> (pool) sometype;

//and

sometype *p = <sometype> new (pool) sometype;

None of them compile. Syntax errors for each case.

**matsp** · 05-22-2008

Ah, ok, I see what the problem is (but I don't really know how to fix it): Your pool depends on the type of the object you are creating.

I think you need something like:

Code:

sometype *p = new (pool<sometype>) sometype;

Although, it's probably more that pool needs to be created with the right type, and that particular type of pool passed along.

I may of course be completely wrong.

--
Mats

**krappa** · 05-22-2008

That's pretty much it. Except I don't want the MemoryPool to be fixed to only one type.

Is there any other way to get type information inside the new definition?

**phantomotap** · 05-22-2008

For my benefit, wht does 'rPool.Allocate<T>(size);' do?

Is there any other way to get type information inside the new definition?

Several.

Wrap 'T' for example:

Code:

template <class T>
inline void* operator new(size_t size, MemoryPool& rPool, const wrap<T> & ignored)
{
  return rPool.Allocate<T>(size);
}

Code:

int * i = new (pool, wrap<int>()) int;

Soma

**anon** · 05-22-2008

I think the templates are not necessary. operator new returns a void* and doesn't care about the type and the size is passed automatically.

(new is a two-step thing: first your global operator new is called and then the object is constructed in the void* that was returned. Finally a pointer of the correct type is returned to the caller. Or something like that.)

Code:

#include <iostream>
#include <cstdlib>

class MemoryPool
{
    public:
    //no templates here
    void* Allocate(size_t size)
    {
        std::cout << "Allocating " << size << '\n';
        return malloc(size); //can't use new?
    }
    //TO DO: Dealloc
};

inline void* operator new(size_t size, MemoryPool& rPool)
{
  return rPool.Allocate(size);
}

//TO DO: operator delete

struct Test
{
    Test() { std::cout << "Test::Test()\n"; }
    void test() const { std::cout << "I'm OK\n"; }
};

int main()
{
    MemoryPool pool;
    Test* n = new (pool) Test;
    n->test();
}

You probably should find more reading about it (for example Thinking in C++, vol.1, chapter 13).

**phantomotap** · 05-22-2008

I think the templates are not necessary. operator new returns a void* and doesn't care about the type and the size is passed automatically.

(new is a two-step thing: first your global operator new is called and then the object is constructed in the void* that was returned. Finally a pointer of the correct type is returned to the caller. Or something like that.)

This is why I'm curious about what it does; from the look of the thing he is trying to construct objects inside 'operator new'. It also seems that he is very close to asking "How do I call "'placement delete'"?".

Soma

**krappa** · 05-22-2008

Originally Posted by phantomotap

For my benefit, wht does 'rPool.Allocate<T>(size);' do?

Actually, this isn't the right syntax. The pool is still work in progress, so I wasn't clear where to put some stuff.
Basically, I'm storing a pointer to the destructor of the new object so that I can "roll back" when clearing the pool. Without the need for the pool user to explicitly call the destructor.

EDIT: but this won't work since the destructor doesn't exist yet, inside the "new". I should've thought this through...

**anon** · 05-22-2008

I didn't even know that you can take the address of the destructor! But if you could, it probably wouldn't matter if you had an instance or not (just like with member function pointers).

So what are you trying to write - a garbage collector? (If so, perhaps consider smart pointers instead...)

**matsp** · 05-22-2008

Of course you can take the address of it (just like you can ANY function in C or C++), but you also need to remember the instance that it belongs to and then call it with a copy (pointer to) the original instance, as the "this" value needs to be correct when destroying the object.

--
Mats

**laserlight** · 05-22-2008

Of course you can take the address of it (just like you can ANY function in C or C++), but you also need to remember the instance that it belongs to and then call it with a copy (pointer to) the original instance, as the "this" value needs to be correct when destroying the object.

Eh, the C++ Standard states in section 12.4: "The address of a destructor shall not be taken."

**matsp** · 05-22-2008

Originally Posted by laserlight

Eh, the C++ Standard states in section 12.4: "The address of a destructor shall not be taken."

Ok, fair enough - so don't do that then... ;-)

In fact, I wasn't even getting a sensible error out of g++ when I tried - but I'm not entirely sure what the syntax would actually be.

--
Mats

**krappa** · 05-22-2008

So since I didn't have the destructor, I decided to wrap the destruction in a static template function:

Code:

typedef uint8* (*DtorType)(uint8*);

template <class T> uint8* Dtor(uint8* pToDelete)
{
  T* pObj = (T*)(pToDelete - sizeof(T));
  pObj->~T();
  return pObj;
}

and here is the templated allocation in the mempool. mpCurrent is the current pointer (uint8*) in the pool.

Code:

 template <class T> void* Allocate()
  {
    if ((mpCurrent + sizeof(T) + sizeof(DtorType)) > (mpMemory + mSize))
    {
      return NULL;
    }
    else
    {
      uint8* pRet = mpCurrent;
      mpCurrent += sizeof(T);

      //this line is the problem
      *mpCurrent = &Dtor<T>;

      mpCurrent += sizeof(DtorType);
      return pRet;
    }
  }

This compiles on Apple G++ 4.0.1.
But if I try to use the new operator, I get an error:
cannot resolve overloaded function 'Dtor' based on conversion to type 'unsigned char'

And it doesn't even compile in Visual C++:
cannot convert from 'uint8 *(__cdecl *)(uint8 *)' to 'uint8'

I tried replacing uint8* with void*, but I can't perform arithmetic operations on a void* type.

**Elysia** · 05-22-2008

I don't understand the code, but you are doing something weird.
If mpCurrent is defined as uint8*, then you try to assign the address of a function to a uint8 variable?
And in case you wanted the return value of the destructor, it returns uint8*, not uint8.

Thread: operator new overloading and template functions

Thread Tools

Search Thread

Display

operator new overloading and template functions

Similar Threads

template overloading question

template plus ambiguous overloading!!

Template overloading?

Operator overloading for an inner class of a class template causes compilation error

Operator Overloading and passing a template into COnstructor