Re: explicit call of constructor and destructor
First off, thank you very much for the help so far!
On Dec 5, 5:36 pm, James Kanze <james.ka...@gmail.com> wrote:
On Dec 5, 6:03 am, Abhishek Padmanabh <abhishek.padman...@gmail.com>
wrote:
operator new/operator delete overloads should match the
signature of their global forms provided by the compiler.
If the signatures match, then it's not an overload, it's a
replacement.
Yes, exactly. I think this was the basic mis-understanding I was
having. Let's see if it is gone now.
And then when the objects of the class, for which these are
overloaded, are created using new expression, use the operator
new overload for allocation and the corresponding operator
delete for deallocation.
If placement allocation function and placement deallocation
functions also manage allocation and deallocation then what is
different between these and the above overloads?
They use different algorithms?
Right, now I think what I was confused about. There are certain
overloads to operator new/operator delete that can only be called
using the placement new form/expression. These overloads are called
placement allocation/deallocation forms. I was thinking that these
overloads were different from the placement allocation/deallocation
forms which I think is wrong. Could you please see my understanding
below and confirm on those points?
The most frequent case I've seen is something like:
void* operator new( size_t n, MemoryPool& ) ;
void operator delete( void* p, MemoryPool& ) ;
Invoked by something like:
MemoryPool pool1 ;
T* p = new ( pool1 ) T ;
In this case, you probably need the placement delete, since if
the constructor fails, you want to delete the memory. (Or maybe
the pools are garbage collected in some way, and you don't need
it.)
Should it be deleting the memory? Shouldn't the MemoryPool be the one
managing it? And this operator delete doing just some pointer
adjustments? Please see below as well.
Just that if the signature if a direct match with operator
new/operator delete,
If the signature is a direct match, they are replacements, not
overloads.
they are overloads else they are placement allocation
functions?
Also, referring to the example as in 5.3.4 (20) as below:
struct S {
// Placement allocation function:
static void* operator new(std::size_t, std::size_t);
// Usual (non-placement) deallocation function:
static void operator delete(void*, std::size_t);
};
S* p = new (0) S; // ill-formed: non-placement deallocation function
matches
// placement allocation function
This is a special case. The problem with member operator delete
is that the non-placement form can have one of two different
signatures. Which leads to an ambiguity if the placement form
of new takes a size_t as it's additional argument: is the
operator delete, above, a placement form (which should be called
if the constructor in a corresponding placement new throws), or
is it the standard form (in which case, it will only be called
if non-placement new is used).
On the whole, my comments didn't take member overloads of
operator new into consideration, but except for the fact that
the non-placement delete can have one of two different
signatures, the rules are pretty much the same. Of course, the
name lookup rules means that a placement operator new in a class
will hide the global non-placement operator, so objects of that
type can only be created by placement new.
Regarding the 2 forms (and this special case), please see below.
More generally, overloading operator new and operator delete can
be tricky; it's not something for beginners.
Sorry, I know I am not an expert but that hurts. I just want to
understand it else it will keep haunting me.
The standard also says (in 18.5.1.3 - Placement forms) that the
placement form function is reserved and a C++ program may not define
them that would displace these? Is that specific to the form as below:
void* operator new(std::size_t size , void* ptr ) throw();
and if I had a different argument list for this - would that be
allowed?
Exactly. You are not allowed to replace this form of placement
new, since much of the standard library code probably depends on
it having exactly the semantics provided for by the standard
library.
Yes, these cannot be replaced but overloaded. :)
Note that at a language level, there's nothing special about
this level. As far as the compiler is concerned, the new
expression behaves as always: it calls an allocator function to
acquire the memory, then the constructor of the object. Because
this particular placement new is declared nothrow, the compiler
will also generate code to check that the returned pointer is
not null before calling the constructor. Because the library
also declares a corresponding placement delete, the compiler
will also generate code to ensure that it is called if the
constructor exits via an exception. (I've often wondered about
this; the semantics of the corresponding placement delete are to
do nothing, so I don't see the reason behind having it, and
getting it called. Perhaps just to prevent user code from
accidentally declaring it.)
Yes, it looks pretty useless but it is good to have a consistent
semantics. Here is my understanding as of now. Could you please
suggest if it looks right or wrong?
The global operator new and delete have the following signatures:
1. void* operator new(std::size_t) throw(std::bad_alloc); //single
object form throws std::bad_alloc
2. void* operator new[](std::size_t) throw(std::bad_alloc); //array
form - throws bad alloc
3. void* operator new(std::size_t size , const std::nothrow_t&)
throw(); //nothrow new
4. void* operator new[](std::size_t size , const std::nothrow_t&)
throw(); //no throw array form of new
5. void operator delete(void*) throw(); //single object form
6. void operator delete[](void*) throw(); //array form
7. void operator delete(void* , const std::nothrow_t&) throw(); //
corresponds to nothrow new
8. void operator delete[](void* , const std::nothrow_t&) throw(); //
corresponds to nothrow array form of new
To use 3 and 4 (related to 7 and 8 versions of operator delete),
placement form of new is used wherein there is an argument list
attached to new, as in A * ptr = new (nothtow) A();
Another set of overload for operator new/operator delete are provide
that are used for in-place construction. They are declared as below:
9. void* operator new(std::size_t size , void* ptr ) throw();
10. void* operator new[](std::size_t size , void* ptr ) throw();
11. void operator delete(void* ptr , void*) throw();
12. void operator delete[](void* ptr , void*) throw();
These are provided by the standard library and these can not be
replaced in the sense that no operator new/operator delete sets would
be defined by a program with the above 4 signatures (9 through 12).
These two operator new's don't do allocation and hence operator
delete's don't do any deallocation. The operator new just returns the
pointer ptr (no other action performed) and operator delete does not
perform any action. The operator delete is just a function that gets
called in case the constructor of the object being constructed on ptr
throws an exception.
These come to use when doing in-place construction as below:
char* buffer = new char[sizeof(A)];
A * ptrToA = new (buffer) A();
ptrToA->~A();
delete[] buffer;
If class provides replacements for functions 1 through 8 in their
class, they must have the same signature as shown in 1-8. And then
when that object is created via new expression or the placement new
nothrow form, these replacement versions will be called and
corresponding operator deletes will be called when the object is to be
normally destroyed or if the constructor of that class throws an
exception.
There can be other overloads to operator new/operator delete that can
only be called using placement new expression (the below can have any
more number of arguments - the argument list between the operator new
and delete must match except for the first argument). For example:
13. void* operator new(std::size_t size, MemoryPool& mempool) throw();
14. void* operator new[](std::size_t size, MemoryPool& mempool)
throw();
15. void operator delete(void* ptr, MemoryPool& mempool) throw();
16. void operator delete[](void* ptr, MemoryPool& mempool) throw();
One example way to use this is that the operator new would be checking
what portion of that pool they can utilize and make pointer
adjustments on the pool and return a pointer to the location wherein
the construction of the object can take place. Ideally, operator
delete should not deallocate the memory because it is part of the pool
and is being managed by the pool. It would work the same way as the
operator delete mentioned in 11 and 12. Maximum they can do it, using
MemoryPool's interface, can mark the area re-usable on which the
object was constructed since the destructor must have got called
before this operator delete gets called. If the operator delete is
deallocating memory then the advantage of a pool is lost since the
intent is to minimize system calls for acquiring and freeing memory.
It is not mandatory that you have this behavior but I am just thinking
from the point of view that the MemoryPool I am using is to allocate a
huge chunk of buffer at start-up and keep re-using it to create
objects on without making repeated calls to the system for memory
acquisition and freeing.
Now, coming to the special case,
17. void* operator new(std::size_t, std::size_t);
18. void operator delete(void * ptr, size_t);
This is still a problem for me. How is the operator delete a non-
placement deallocation function? The non-placement deallocation
function would have the signature matching 5 and 6. Right? Because
only 1 and 2 forms of operator new and their replacements are the only
ones that can be called by the new expression. For all the rest, the
placement new form must be used to supply those additional arguments.
If 18 is the second form of the non-placement allocation function,
(because you say there are 2 forms, one is the form in 5 and 6, I
believe this is the second one that you are pointing to), could you
please quote the standards section that says so?
Please bear with me. :) Thanks very much, once again.