Re: Is this a new syntax
"Alf P. Steinbach" <alfps@start.no> wrote in message
news:4vudnViietNPBq_VnZ2dnUVZ_ovinZ2d@posted.comnet...
* kwikius:
"Alf P. Steinbach" <alfps@start.no> wrote in message
No, placement new doesn't call a constructor "directly". The
constructor arguments you pass are forwarded to a constructor, not
passed directly as in an ordinary function call. In between there's a
lot going on, including preparation of cleanup in the event that the
constructor throws.
Not sure what you mean.
In general it has to arrange for calling the corresponding deallocation
function when a constructor throws. For a custom allocation function this
is the only way that the corresponding custom deallocation function can be
implicitly called, and it implies that for this, the allocation function
argument(s) must be stored, and an exception handler set up.
Well I dont see the O.P. expression as *allocation*. IMO its construction at
a preallocated address.
For placement new of array of objects, if the exception will eventually be
caught higher up somewhere, then it also has to arrange for calling
destructors of already successfully constructed objects, in reverse order.
However, I fail to find this requirement in the standard. It must be
there somewhere...
I modified my original code, shows that (this is I think internal
implementation level stuff now) the implementation pushes the address of the
dtor, and does unwind back sequence on exception
Now with placement new array ("construct n elements at base memory
address")it is less trivial to use malloc. There is some housekeeping data
required presumably at the head of the allocation. I assumed here its size
of a pointer.
Nevertheless I don't agree that its that difficult or experts only. One
thing that C++ has and more modern languages which are biting at C++ heels
don't , is direct access to the hardware. Its a pain in the ass from some
viewpoints (e.g the "portable" size of int etc), but it might as well be
pointed out as a very powerful and instructive feature. It shows you the
relation between software and hardware.
Of course that assumes that hardware stays "rigid", though one day it may
become more "miscible" with software :
http://www.youtube.com/watch?v=_ILu5SMis9E
:-)
Anyway here is the code:
#include <iostream>
#include <stdexcept>
#include <string>
#include <cstring>
#include <malloc.h>
/*sic*/
#include <new>
struct my{
my()
: text(0)
{
std::cout << "Enter some text\n";
std::string str;
getline(std::cin,str);
if (str == "throw"){
throw std::logic_error(" I TOLD YOU not to input \"throw\" ...
DUMBASS");
}
text = new char [str.length()+1];
strcpy(text,str.c_str());
}
~my()
{
std::cout << "text = \"" << text << "\" in my dtor \n";
delete [] text;
}
private:
my (my const &);
my & operator = ( my const &);
char * text;
};
template < typename T>
void deconstruct(T* p)
{
p->~my();
}
template <typename T>
void deconstruct(T* p, size_t n)
{
for (size_t i = 0; i != n; ++i){
deconstruct(&p[i]);
}
}
void* array_malloc(size_t size)
{
//allow size_t for house_keeping
//implementation defined
#ifdef _MSC_VER
// don't quote me ;-)
static const int ar_info = sizeof(size_t*);
#endif
return malloc(size + ar_info);
}
int main()
{
static const size_t NUM =2;
// (malloc guarantees alignment)
void * allocation = array_malloc(sizeof (my) * (NUM));
my* pmy=0;
if(allocation != NULL){
//construct a my at allocation
// input at prompt "throw" to throw
try{
/*sic */
pmy = ::new (allocation) my[NUM]; // Line 71
deconstruct(pmy,NUM);
/*
ASM-----------
; Line 71
push OFFSET ??1my@@QAE@XZ ; my::~my
push OFFSET ??0my@@QAE@XZ ; my::my
push 2
push 4
lea esi, DWORD PTR [ebx+4]
mov DWORD PTR __$EHRec$[ebp+12], 1
push esi
mov DWORD PTR [ebx], 2
call ??_L@YGXPAXIHP6EX0@Z1@Z
mov edi, esi
mov BYTE PTR __$EHRec$[ebp+12], 0
mov DWORD PTR _pmy$[ebp], edi
; Line 72
xor esi, esi
npad 7
$LL20@main:
cmp esi, 2
je SHORT $LN13@main
lea ecx, DWORD PTR [edi+esi*4]
call ??1my@@QAE@XZ ; my::~my
inc esi
jmp SHORT $LL20@main
//end ASM ---------------
*/
}
catch(std::exception & e){
std::cout << e.what();
if(pmy){
std::cout << " and throw... twas messy bad \n";
}else{
std::cout << ", ... but throw.. twas neat \n";
}
}
free(allocation);
}
}
By the way, there's no placement delete: no way to pass deallocation
function arguments in a delete expression.
Below is some code and some asm interspersed at the significant line 42
The standard tells you what placement new syntax is required to achieve.
The generated assembly code tells you how a given compiler implements
those requirements for any given special case.
For example, if the deallocation function does nothing, then it would be
silly to not optimize that part away. :-)
That is the default for placement new at an address. I dont see it as
allocation. I see it as constructing an object at an address. I think that
is what the O.P. code was too..
And in this case it can be seen as a direct call to ctor IMO.
Cheers, & hth.,
- Alf
PS: In order to use placement new for in-place construction (which is
where the name comes from), formally you need to include <new>, and
practically it's a good idea to then use "::" qualification (?5.3.4/5) in
order not to pick up the class' own user defined allocation function, if
it has one.
OK.