Re: Copy-less initialization of a TR1 array
On Nov 11, 8:09 am, zr <zvir...@gmail.com> wrote:
On Nov 10, 6:35 pm, Maxim Yegorushkin <maxim.yegorush...@gmail.com>
wrote:
On Nov 10, 4:20 pm, Vidar Hasfjord <vattilah-gro...@yahoo.co.uk>
wrote:
On Nov 10, 12:30 pm, zr <zvir...@gmail.com> wrote:
Hi,
Is there a way to initialize a std::tr1::array with a pre-allocated
built-in array in a copy-less assignment, such that both will point=
to
the same memory?
Yes, you can use 'placement new':
typedef array <int, 4> A;
int init [] = {1, 2, 3, 4};
A& a = *new (init) A;
A may overflow init.
Of course, this is equivalent to
array <int, 4> a = {1, 2, 3, 4};
Only with POD types. If you replace int with a non-trivial type, this
code will end up calling constructors twice and destructors only once.
I had to write a small test to realize the problem, though i don't
understand what is really happening.
Max, or anyone could you please elaborate?
#include <array>
#include <iostream>
using namespace std::tr1;
using namespace std;
class A
{
public:
A():value(10) { cout << "A() c-tor\n"; }
A(const int& _value):value(_value) { cout << "A(const int=
& _a) c-tor
\n"; }
~A() { cout << "A d-tor\n"; }
int value;
};
int main(int argc, char* argv[])
{
A cArray[] = { 1 , 2, 3, 4};
array<A,4>& tr1Array = *new(cArray) array<A,4>;
for (int i=0; i<4; i++)
cout << cArray[i].value << " ";
cout << endl;
for (int i=0; i<4; i++)
cout << tr1Array[i].value << " ";
cout << endl;
return 0;
}
output:
A(const int& _a) c-tor
A(const int& _a) c-tor
A(const int& _a) c-tor
A(const int& _a) c-tor
A() c-tor
A() c-tor
A() c-tor
A() c-tor
10 10 10 10
10 10 10 10
A d-tor
A d-tor
A d-tor
A d-tor
Here is a modified version of your code with a bit more insightful
output (I don't have tr1::array thus boost::array is used):
#include <boost/array.hpp>
#include <iostream>
using boost::array;
using namespace std;
struct A
{
A():value(0) { cout << "A@" << static_cast<void*>(this) << "("
<< value << ") c-tor\n"; }
A(int value):value(value) { cout << "A@" <<
static_cast<void*>(this) << "(" << value << ") c-tor\n"; }
~A() { cout << "A@" << static_cast<void*>(this) << "(" <<
value << ") d-tor\n"; }
int value;
};
int main()
{
cout << "constructing cArray\n";
A cArray[] = { 1 , 2, 3, 4};
cout << "constructing array<>\n";
array<A,4>& tr1Array = *new(cArray) array<A,4>;
cout << "destroying cArray\n";
}
This code yields the following output:
constructing cArray
A@0013FF48(1) c-tor
A@0013FF4C(2) c-tor
A@0013FF50(3) c-tor
A@0013FF54(4) c-tor
constructing array<>
A@0013FF48(0) c-tor
A@0013FF4C(0) c-tor
A@0013FF50(0) c-tor
A@0013FF54(0) c-tor
destroying cArray
A@0013FF54(0) d-tor
A@0013FF50(0) d-tor
A@0013FF4C(0) d-tor
A@0013FF48(0) d-tor
As you can see the elements of cArray are overwritten with new(cArray)
array<A,4>. This is because placement new operator treats its cArray
argument as uninitialised memory.
At the end of the scoped the destructors of cArray objects are invoked
(in the reverse order of construction). However, these are not the
original cArray objects.
It is important to understand what happens under the hood of the C++
object model, however, Victor told you the right thing - these are way
too brittle tricks which are bound to wreck havoc in your code sooner
or later.
Is there a reason you can't use tr1::array instead of plain C-style
arrays?
--
Max