Copy-less initialization of a TR1 array

[zr]

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?
Vice-versa is easy to do, simply use std::t1::array::data() and assign
the returned value to the c-style pointer;

if STL does not support this, is there any other library that has such
a container (maybe BOOST)?

Here is an example of what i have in mind:

#include <array>
using namespace std::tr1;

int main()
{

int cArray[] = { 1 , 2, 3, 4};

array<int,4tr1Array(cArray); // Using some imaginary c-tor. Don't
want to copy. Want to use preallocated memory

tr1Array[0] = 42;
assert(tr1Array[0] == cArray[0] == 42); // Both point to same memory

tr1Array[100] = 42; //In debug builds, this should raise an exception
cArray[100] = 42; //Much harder to catch

return 0;
}

[Maxim Yegorushkin]

On Nov 10, 12:30*pm, zr <[e-mail]:

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?

There is a way. Disclaimer: it is not blessed by the standard.

Vice-versa is easy to do, simply use std::t1::array::data() and assign
the returned value to the c-style pointer;

if STL does not support this, is there any other library that has such
a container (maybe BOOST)?

Here is an example of what i have in mind:

#include <array>
using namespace std::tr1;

int main()
{

int cArray[] = { 1 , 2, 3, 4};

array<int,4tr1Array(cArray); // Using some imaginary c-tor. Don't
want to copy. Want to use preallocated memory

Here you do:

// make sure that the binary layouts of
// array<and C-array are the same
typedef int static_assert[sizeof(array<int,4>) == sizeof(cArray) ?
1 : -1];
// now do the hack
array<int,4>& tr1Array = reinterpret_cast<array<int,4>&>(cArray);

tr1Array[0] = 42;
assert(tr1Array[0] == cArray[0] == 42); // Both point to same memory

tr1Array[100] = 42; //In debug builds, this should raise an exception
cArray[100] = 42; //Much harder to catch

return 0;

}

--
Max

[zr]

On Nov 10, 3:52*pm, Maxim Yegorushkin <[e-mail]>
wrote:

On Nov 10, 12:30*pm, zr <[e-mail]:

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?

There is a way. Disclaimer: it is not blessed by the standard.

Vice-versa is easy to do, simply use std::t1::array::data() and assign
the returned value to the c-style pointer;

if STL does not support this, is there any other library that has such
a container (maybe BOOST)?

Here is an example of what i have in mind:

#include <array>
using namespace std::tr1;

int main()
{

int cArray[] = { 1 , 2, 3, 4};

array<int,4tr1Array(cArray); // Using some imaginary c-tor. Don't
want to copy. Want to use preallocated memory

Here you do:

* * // make sure that the binary layouts of
* * // array<and C-array are the same
* * typedef int static_assert[sizeof(array<int,4>) == sizeof(cArray) ?
1 : -1];
* * // now do the hack
* * array<int,4>& tr1Array = reinterpret_cast<array<int,4>&>(cArray);

tr1Array[0] = 42;
assert(tr1Array[0] == cArray[0] == 42); // Both point to same memory

tr1Array[100] = 42; //In debug builds, this should raise an exception
cArray[100] = 42; //Much harder to catch

return 0;

}

--
Max

Thanks, Max. I wonder if there is a similar trick for casting a
dynamic array to a std::vector...

[AnonMail2005]

On Nov 10, 7:30*am, zr <[e-mail]:

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?
Vice-versa is easy to do, simply use std::t1::array::data() and assign
the returned value to the c-style pointer;

if STL does not support this, is there any other library that has such
a container (maybe BOOST)?

Here is an example of what i have in mind:

#include <array>
using namespace std::tr1;

int main()
{

int cArray[] = { 1 , 2, 3, 4};

array<int,4tr1Array(cArray); // Using some imaginary c-tor. Don't
want to copy. Want to use preallocated memory

tr1Array[0] = 42;
assert(tr1Array[0] == cArray[0] == 42); // Both point to same memory

tr1Array[100] = 42; //In debug builds, this should raise an exception
cArray[100] = 42; //Much harder to catch

return 0;

}- Hide quoted text -

- Show quoted text -

The issue with doing that is that once you have a container, you
should be able to do whatever you want with it (e.g. changing it's
elements). So unless you put it behind an interface (e.g. a function
or class) that returns a const container, it won't work.

You can use constant built in arrays by passing around a pair of it's
begin and end const iterators. Client code that uses it only knows
that it's a const container and has no knowledge of what kind of
container.

HTH

[Victor Bazarov]

zr wrote:

On Nov 10, 3:52 pm, Maxim Yegorushkin <[e-mail]>
wrote:

>On Nov 10, 12:30 pm, zr <[e-mail]:

>>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?

There is a way. Disclaimer: it is not blessed by the standard.

>>Vice-versa is easy to do, simply use std::t1::array::data() and assign
the returned value to the c-style pointer;
if STL does not support this, is there any other library that has such
a container (maybe BOOST)?
Here is an example of what i have in mind:
#include <array>
using namespace std::tr1;
int main()
{
int cArray[] = { 1 , 2, 3, 4};
array<int,4tr1Array(cArray); // Using some imaginary c-tor. Don't
want to copy. Want to use preallocated memory

Here you do:

// make sure that the binary layouts of
// array<and C-array are the same
typedef int static_assert[sizeof(array<int,4>) == sizeof(cArray) ?
1 : -1];
// now do the hack
array<int,4>& tr1Array = reinterpret_cast<array<int,4>&>(cArray);

>>tr1Array[0] = 42;
assert(tr1Array[0] == cArray[0] == 42); // Both point to same memory
tr1Array[100] = 42; //In debug builds, this should raise an exception
cArray[100] = 42; //Much harder to catch
return 0;
}

--
Max

Thanks, Max. I wonder if there is a similar trick for casting a
dynamic array to a std::vector...

Well, yes, by all means. If you don't care about portability, open up
the definition of the 'vector' class, make sure there are no explicit
specialisations for your type, then stuff the data you have into the
struct that has exactly same layout as your 'vector' class, then just
cast the reference to struct to your vector. Just make sure you never
attempt to change the vector, or grow it, or do anything that might
break the fragile state of that Frankenstein monster you're going to put
together. And don't come crying to us when your program doesn't work,
because we won't be able to explain it. It will have *undefined* behaviour.

Come on, give it up and realise that you'll be much better off using the
standard means and worrying about the design at the higher level than
that, and not about the whatever tiny performance improvement you can
squeeze from your program by using such nonsensical approaches. Really.

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

[Vidar Hasfjord]

On Nov 10, 12:30*pm, zr <[e-mail]:

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, 4A;
int init [] = {1, 2, 3, 4};
A& a = *new (init) A;

Of course, this is equivalent to

array <int, 4a = {1, 2, 3, 4};

Regards,
Vidar Hasfjord