Why does this implementation of the C++ 'new' operator work?

Question

I've found out that the C++ compiler for AVR uCs doesn't support the new and delete operators, but also that there is a quick fix:

void * operator new(size_t size) 
{ 
  return malloc(size); 
} 

void operator delete(void * ptr) 
{ 
  free(ptr); 
}

I'm assuming that it would now be possible to call new ClassName(args);.

However, I am not really sure how this works. For example, what actually returns a size_t here? I thought that constructors don't return anything...

Could it be that new is now supposed to be used differently (in conjunction with sizeof())?

don't confuse new and operator new. Yes it's slightly tricky. operator new which you are overloading just allocates memory. You can use malloc or a special memory pool and you can decorate it too to help with memory leak detection and invalid deletes etc. — CashCow, Jan 09 '13 at 12:31
Does this mean that it doesn't actually instantiate the class at all or what? I'm a bit confused by what you said. — corazza, Jan 09 '13 at 12:34
always keep in mind that the operator new (that you can overload) and the new expression (that you normally use to create new objects in code) are two different things. — PlasmaHH, Jan 09 '13 at 12:39
@PlasmaHH, OK, I didn't know that. Hopefully the compiler supports the new expression. — corazza, Jan 09 '13 at 12:41
In http://www.avrfreaks.net/index.php?name=PNphpBB2&file=viewtopic&t=59453&start=all&postdays=0&postorder=asc you can found the answer. — Mihai8, Jan 09 '13 at 12:53

R. Martinho Fernandes · Accepted Answer · 2013-01-09T12:41:21.293

9

new T(args); is roughly equivalent to the following.

void* storage = operator new(sizeof(T)); // obtain raw storage
call_constructor<T>(storage, args); // make an object in it

(Here call_constructor is supposed to call the constructor^† of T making storage be the this pointer within that constructor.)

The operator new part obtains the requested amount of raw storage, and the constructor call is the one that actually makes an object, by invoking the constructor.

The code in the question only replaces the operator new part, i.e. the retrieval of storage. Both the sizeof part and the constructor invocation are done automatically by the compiler when you use new T(args).

† The language has a way to express this direct constructor invocation called "placement new", but I omitted it for clarity.

edited Jan 09 '13 at 12:41

answered Jan 09 '13 at 12:34

R. Martinho Fernandes

228,013
71
433
510

I thought the `operator` part was part of the operator defining syntax... So I need to add that `call_constructor` part somewhere? – corazza Jan 09 '13 at 12:38
@Yannbane No, that the compiler knows how to do. I made the answer more explicit on that point. – R. Martinho Fernandes Jan 09 '13 at 12:40
OK, I just learned that the "new expression" and "operator new" are two different things, so I figured that part out. Thanks! – corazza Jan 09 '13 at 12:41
For call_constructor you could write new(storage) T(args); of course – CashCow Jan 09 '13 at 13:20
@CashCow yeah, that's what I mention in the footnote, but I thought adding another syntax involved `new` into the mix would make the explanation more confusing. :( – R. Martinho Fernandes Jan 09 '13 at 13:24

score 0 · Answer 2 · answered Jan 09 '13 at 12:37

From the compiler name (uC), I presume it's for embedded controller. This would make sense as you rarely require dynamic memory management with embedded devices, but might benefit from 'C with classes'. Hopefully it supports 'placement new' so you can actually use C++.

If your compiler doesn't support new & delete, it's not really much of a a C++ compiler is it!

I think the keyword 'new' effectively gets converted to:

Object* pointer = (Object *)new(sizeof Object);
pointer->Object_Constructor(args);

Why does this implementation of the C++ 'new' operator work?

2 Answers2