Move data

[In a little while]

i have a block of data -- integer type, i need to move them to some
given addresses, is this possible ? thanks

[dudordoo123456]

In a little while wrote:

i have a block of data -- integer type, i need to move them to some
given addresses, is this possible ? thanks

that doesn't make sense, data stored in memory at specific address
randomly distributed by OS,

you can copy from one to another where the memory locations are
initialised by the the Os too

[rTrenado]

Very true I have to say, however, the answer to the question is still a
yes.

du************@yahoo.dk wrote:

In a little while wrote:

i have a block of data -- integer type, i need to move them to some
given addresses, is this possible ? thanks

that doesn't make sense, data stored in memory at specific address
randomly distributed by OS,

you can copy from one to another where the memory locations are
initialised by the the Os too

[koda5555555555]

du************@yahoo.dk wrote:

that doesn't make sense, data stored in memory at specific address
randomly distributed by OS,

you can copy from one to another where the memory locations are
initialised by the the Os too

That's not true, Os has nothing to deal with this case,,,, compiler
does that by allocating different chunks for use

regards
-Kinai

[Salt_Peter]

In a little while wrote:

i have a block of data -- integer type, i need to move them to some
given addresses, is this possible ? thanks

Possible, yes.
Let the block of data be a container of integers and it will not only
be possible, it'll be safe and lightning fast.
Suggestion: std::swap

Here is a block:

#include <iostream>
#include <vector>

template< typename T>
struct Block
{
Block(size_t sz) : vt(sz) { }
std::vector< T vt;
};

int main()
{
Block< int block(1000000);
std::vector< int vn(1000000, 99); // on million 99s

vn.swap(block.vt);
}

I tried it with 80 MB too, holy cow that swap is fast.

[Greg]

Salt_Peter wrote:

In a little while wrote:

i have a block of data -- integer type, i need to move them to some
given addresses, is this possible ? thanks

Possible, yes.
Let the block of data be a container of integers and it will not only
be possible, it'll be safe and lightning fast.
Suggestion: std::swap

Here is a block:

#include <iostream>
#include <vector>

template< typename T>
struct Block
{
Block(size_t sz) : vt(sz) { }
std::vector< T vt;
};

int main()
{
Block< int block(1000000);
std::vector< int vn(1000000, 99); // on million 99s

vn.swap(block.vt);
}

I tried it with 80 MB too, holy cow that swap is fast.

First, why recommend std::swap() and then provide a sample program that
calls a different routine?

Note also that vector::swap() merely exchanges two pointers - so
vector::swap() is a constant-time operation no matter how large the
vectors may be. And yes, exchanging two pointers is a fast operation.

The original question concerned copying a block of integers to a given
address in memory. Assuming that the destination address has been
properly allocated with enough room to hold the data to be copied, then
the program can call std::memcpy() to transfer the bytes to the
destination address.

Greg

[Salt_Peter]

Greg wrote:

Salt_Peter wrote:

In a little while wrote:

i have a block of data -- integer type, i need to move them to some
given addresses, is this possible ? thanks

Possible, yes.
Let the block of data be a container of integers and it will not only
be possible, it'll be safe and lightning fast.
Suggestion: std::swap

Here is a block:

#include <iostream>
#include <vector>

template< typename T>
struct Block
{
Block(size_t sz) : vt(sz) { }
std::vector< T vt;
};

int main()
{
Block< int block(1000000);
std::vector< int vn(1000000, 99); // on million 99s

vn.swap(block.vt);
}

I tried it with 80 MB too, holy cow that swap is fast.

First, why recommend std::swap() and then provide a sample program that
calls a different routine?

It doesn't matter which one you call:
std::swap(v1,v2) will feed into the vector's own swap anyways.

>
Note also that vector::swap() merely exchanges two pointers - so
vector::swap() is a constant-time operation no matter how large the
vectors may be. And yes, exchanging two pointers is a fast operation.

Thats 3 pointers on most implementations.

>
The original question concerned copying a block of integers to a given
address in memory. Assuming that the destination address has been
properly allocated with enough room to hold the data to be copied, then
the program can call std::memcpy() to transfer the bytes to the
destination address.

I'm aware of that. I still contend that there is a better solution,
hence my recommendation.
You are free to disagree, as you have. In this case, its just an
accident that padding isn't involved.
And, for the record, in a group like this one. memcpy should be
discouraged. Period.

>
Greg

[Jim Langston]

"In a little while" <cp****************@yahoo.comwrote in message
news:11*********************@m7g2000cwm.googlegrou ps.com...

>i have a block of data -- integer type, i need to move them to some
given addresses, is this possible ? thanks

Few ways. Simplest being memcpy.

int main()
{
int Data[1000] = { 0 };

int* Buffer = new int[1000];
memcpy( Buffer, Data, 1000 );

// do whatever

delete[] Buffer;

}

Another way, move manually using for loop:

int main()
{
int Data[1000] = { 0 };

int* Buffer = new int[1000];

for ( int i = 0; i < 10000; ++i )
Buffer[i] = Data[i]

// do whatever

delete[] Buffer;

}