help about pointer copy

[Jinjun Xu]

Hi,

I have an array and I want to adjust the size (remove some elements). I use
the following code. Can you help me to check whether it's correct.

////////////// start
int *p1 = new int[oldsize];

// ....
// set the values of p1

int *p2 = p1;
p1 = new int[newsize];

// copy some values from p2 to p1
for ( i = 0; i .... )
if (....) p1[i] = p2[i];

delete []p2;

////////////// end

Suppose I have an array, e.g., int *p1 = new int[10]; is there any easy way
to reset the length of p1? (e.g, p1 becomes int[20] and the first 10
elements keep the original value).

Thank you very much in advance for your help!

JJ

[Victor Bazarov]

"Jinjun Xu" <jj**@ucla.ed u> wrote...

I have an array and I want to adjust the size (remove some elements). I use the following code. Can you help me to check whether it's correct.

////////////// start
int *p1 = new int[oldsize];

// ....
// set the values of p1

int *p2 = p1;
p1 = new int[newsize];

// copy some values from p2 to p1
for ( i = 0; i .... )
if (....) p1[i] = p2[i];

delete []p2;

////////////// end
Seems fine.
Suppose I have an array, e.g., int *p1 = new int[10]; is there any easy way to reset the length of p1? (e.g, p1 becomes int[20] and the first 10
elements keep the original value).

You don't have to change anything in that case. Just think you have
fewer elements and only use as many as you think there are. And, no,
there is no "easy way to reset the length" of a dynamic array.

Victor

[SaltPeter]

inline...

"Jinjun Xu" <jj**@ucla.ed u> wrote in message
news:c9******** **@daisy.noc.uc la.edu...

Hi,

I have an array and I want to adjust the size (remove some elements). I use the following code. Can you help me to check whether it's correct.

////////////// start
int *p1 = new int[oldsize];

// ....
// set the values of p1

int *p2 = p1;
p1 = new int[newsize];

// copy some values from p2 to p1
for ( i = 0; i .... )
if (....) p1[i] = p2[i];

delete []p2;

////////////// end

Suppose I have an array, e.g., int *p1 = new int[10]; is there any easy way to reset the length of p1? (e.g, p1 becomes int[20] and the first 10
elements keep the original value).

Thank you very much in advance for your help!

JJ

The easy way is to use a vector instead of an array. Arrays have a fixed
size limitation while a vector container dynamically resizes itself.
Additionally, all STL containers come equipped with powerful member
functions, iterators and algorithms to swap, sort, replace, append, push,
pop, etc...

as a simple example using a vector of integers and a display function:

#include <iostream>
#include <vector>

void display(std::ve ctor<int>& r_v)
{
std::cout << "vector contents:" << std::endl;

std::vector<int >::iterator it;
for (it = r_v.begin(); it != r_v.end(); it++)
{
std::cout << *it << std::endl;
}
}

int main()
{
std::vector<int > vi;

// add a few elements
vi.push_back(0) ;
vi.push_back(1) ;
vi.push_back(2) ;

std::cout << "vector vi has " << vi.size() << " elements" << std::endl;
display(vi);

// add more elements
vi.push_back(3) ;
vi.push_back(4) ;
vi.push_back(5) ;

std::cout << std::endl << "vector vi has " << vi.size() << " elements"
<< std::endl;
display(vi);

std::cout << std::endl;

return 0;
}

[Dave Moore]

"Jinjun Xu" <jj**@ucla.ed u> wrote in message news:<c9******* ***@daisy.noc.u cla.edu>...

Hi,

I have an array and I want to adjust the size (remove some elements). I use
the following code. Can you help me to check whether it's correct.

////////////// start
int *p1 = new int[oldsize];

// ....
// set the values of p1

int *p2 = p1;
p1 = new int[newsize];

// copy some values from p2 to p1
for ( i = 0; i .... )
if (....) p1[i] = p2[i];

delete []p2;

////////////// end

Suppose I have an array, e.g., int *p1 = new int[10]; is there any easy way
to reset the length of p1? (e.g, p1 becomes int[20] and the first 10
elements keep the original value).

No, there is not a straightforward way to do this with raw pointers.
However you can do what you want using the STL containers std::vector
or std::deque, which will grow automatically as you add data to them.
They also have functions to ensure you have enough space to hold a
minimum number of elements. However, one caveat is that each time
they grow, any pointers (or other iterators) into the container become
invalid.

HTH, Dave Moore

[Jinjun Xu]

Thank you guys for the reply and help! It was my first post in news group
and I am so happy to get the answer quickly and helpfully.

It seems that I should spend more time on learning using the classes in the
C++ library instead of writing from scratch by myself. My work is on
numerical computation so I need to use vector and matrix often. What I did
is to write the classes CVector and CMatrix by myself. Now I know that
vector class may help me much. Thank you.

JJ

"SaltPeter" <Sa*******@Jupi ter.sys> wrote in message
news:hI******** **************@ news20.bellglob al.com...

inline...

"Jinjun Xu" <jj**@ucla.ed u> wrote in message
news:c9******** **@daisy.noc.uc la.edu...

Hi,

I have an array and I want to adjust the size (remove some elements). I use

the following code. Can you help me to check whether it's correct.

////////////// start
int *p1 = new int[oldsize];

// ....
// set the values of p1

int *p2 = p1;
p1 = new int[newsize];

// copy some values from p2 to p1
for ( i = 0; i .... )
if (....) p1[i] = p2[i];

delete []p2;

////////////// end

Suppose I have an array, e.g., int *p1 = new int[10]; is there any easy

way

to reset the length of p1? (e.g, p1 becomes int[20] and the first 10
elements keep the original value).

Thank you very much in advance for your help!

JJ

The easy way is to use a vector instead of an array. Arrays have a fixed
size limitation while a vector container dynamically resizes itself.
Additionally, all STL containers come equipped with powerful member
functions, iterators and algorithms to swap, sort, replace, append, push,
pop, etc...

as a simple example using a vector of integers and a display function:

#include <iostream>
#include <vector>

void display(std::ve ctor<int>& r_v)
{
std::cout << "vector contents:" << std::endl;

std::vector<int >::iterator it;
for (it = r_v.begin(); it != r_v.end(); it++)
{
std::cout << *it << std::endl;
}
}

int main()
{
std::vector<int > vi;

// add a few elements
vi.push_back(0) ;
vi.push_back(1) ;
vi.push_back(2) ;

std::cout << "vector vi has " << vi.size() << " elements" <<

std::endl; display(vi);

// add more elements
vi.push_back(3) ;
vi.push_back(4) ;
vi.push_back(5) ;

std::cout << std::endl << "vector vi has " << vi.size() << " elements"
<< std::endl;
display(vi);

std::cout << std::endl;

return 0;
}

[Darius.Moos AT esigma-systems DOT de]

On Thu, 03 Jun 2004 09:31:32 +0200, Dave Moore wrote:

However you can do what you want using the STL containers std::vector or
std::deque, which will grow automatically as you add data to them. They
also have functions to ensure you have enough space to hold a minimum
number of elements. However, one caveat is that each time they grow,
any pointers (or other iterators) into the container become invalid.

Would you elaborate on this a little bit. Does "... become invalid" mean
that the order and offset of the specific elements in the vector could
change and therefor the pointers/iterators become invalid or does it mean
that the order and offset of the vector-elements keep the same when adding
(push_back()) to a vector and just the references become invalid due to
some vector-internal management ?

Thanks in advance for your answer.

Darius.

[Sullivan]

> It seems that I should spend more time on learning using the classes in
the

C++ library instead of writing from scratch by myself. My work is on
numerical computation so I need to use vector and matrix often. What I did
is to write the classes CVector and CMatrix by myself. Now I know that
vector class may help me much. Thank you.

Try then Newmat library from http://www.robertnz.net/nm_intro.htm

[JKop]

Jinjun Xu posted:

Suppose I have an array, e.g., int *p1 = new int[10]; is there any easy
way to reset the length of p1? (e.g, p1 becomes int[20] and the first
10 elements keep the original value).

Imagine that this is your int[10] in memory:
char double int int int int int int int int int int char double int*
unsigned short int
What I'm getting at is that your int[10] may be boxed-in in memory. Thus,
you're *not guaranteed* that you can make it bigger! You'll have to find an
unused bit of memory of length int[20] and move your values.
-JKop

[Prateek R Karandikar]

> On Thu, 03 Jun 2004 09:31:32 +0200, Dave Moore wrote:

However you can do what you want using the STL containers std::vector or
std::deque, which will grow automatically as you add data to them. They
also have functions to ensure you have enough space to hold a minimum
number of elements. However, one caveat is that each time they grow,
any pointers (or other iterators) into the container become invalid.
Would you elaborate on this a little bit. Does "... become invalid" mean
that the order and offset of the specific elements in the vector could
change and therefor the pointers/iterators become invalid or does it mean
that the order and offset of the vector-elements keep the same when adding
(push_back()) to a vector and just the references become invalid due to
some vector-internal management ?

When you push_back(), the indices of the existing elements remain the
same, however, the iterators become invalid because the elements might
be moved. Consider reserve().

Thanks in advance for your answer.
You're welcome Darius.

!!!!!!!!!!!!!!! !!!!!!!!!!!!!!! !!!!!!!!!!
To iterate is human, to recurse divine.
-L. Peter Deutsch
!!!!!!!!!!!!!!! !!!!!!!!!!!!!!! !!!!!!!!!!

[Dave Moore]

"Darius.Moo s AT esigma-systems DOT de" <pf*********@gm x.de> wrote in message news:<2i******* *****@uni-berlin.de>...

On Thu, 03 Jun 2004 09:31:32 +0200, Dave Moore wrote:

However you can do what you want using the STL containers std::vector or
std::deque, which will grow automatically as you add data to them. They
also have functions to ensure you have enough space to hold a minimum
number of elements. However, one caveat is that each time they grow,
any pointers (or other iterators) into the container become invalid.

Would you elaborate on this a little bit. Does "... become invalid" mean
that the order and offset of the specific elements in the vector could
change and therefor the pointers/iterators become invalid or does it mean
that the order and offset of the vector-elements keep the same when adding
(push_back()) to a vector and just the references become invalid due to
some vector-internal management ?

Thanks in advance for your answer.

Well, the terse answer is that they become invalid because the
Standard says so ... I guess the correct way to interpret this is that
the Standard places no restrictions on compiler developers to make
sure that they remain valid, as it does with (for example) std::list.
What that means in the end is that, it doesn't really matter *how*
they become invalid, but rather that you can no longer rely on them to
behave in the correct way.

Sorry if this is a somewhat unsatisfying answer, but I don't really
know the guts of the STL containers, only (some of) what is in the
Standard, which is all that is required for users. There are good
books and websites to help you learn more about implementation details
if you are interested ... try www.accu.org for more info.

As far as your examples are concerned, I think that either of your
suggestions above might be a (partial) answer for a particular
implementation. Note however that if you start relying on a
particular behavior for something that is specified as undefined (or
even implementation-defined), then somewhere down the line your code
is probably going to break.

HTH, Dave Moore