object arrays

[john townsley]

I want to know how can you have an array of objects declared if you dont
know how many items will be in the array?

eg MyClass Myobject[?];
or
MyClass *Myobject[?]

In VB you could simply have a Redim command where you preserve the existing
array and just add another index. Do you need to go through contatiners?

thanks

[Shan]

john townsley wrote:

I want to know how can you have an array of objects declared if you dont know how many items will be in the array?

eg MyClass Myobject[?];
or
MyClass *Myobject[?]

In VB you could simply have a Redim command where you preserve the existing array and just add another index. Do you need to go through contatiners?
thanks

Use vector which can hold any object of the same type and can grow
dynamically. Checkout the STL to use the vector.
Regards
Shan

[Mike Wahler]

"john townsley" <jo**********@optusnet.com.au> wrote in message
news:42**********************@news.optusnet.com.au ...

I want to know how can you have an array of objects declared if you dont
know how many items will be in the array?
Allocate the array with operator 'new[]'
(and don't forget to deallocate it with
operator 'delete[]' when you're done with
the array.

But imo the superior alternative is to stop
using an array and use a container instead
(e.g. vector).

eg MyClass Myobject[?];
or
MyClass *Myobject[?]

In VB you could simply have a Redim command
C++, 'new/delete' doesn't have that capability. You'd
need to allocate a new array of the new size, copy the
old array elements to it, then delete the old array.
where you preserve the existing
array and just add another index.
Do you need to go through contatiners?

You don't *have* to, but I reccomend it.

A container can be 'grown' or 'shrunk' as needs dictate.

-Mike

[john townsley]

"Mike Wahler" <mk******@mkwahler.net> wrote in message
news:Ih*****************@newsread3.news.pas.earthl ink.net...

"john townsley" <jo**********@optusnet.com.au> wrote in message
news:42**********************@news.optusnet.com.au ...

I want to know how can you have an array of objects declared if you dont
know how many items will be in the array?

Allocate the array with operator 'new[]'
(and don't forget to deallocate it with
operator 'delete[]' when you're done with
the array.

But imo the superior alternative is to stop
using an array and use a container instead
(e.g. vector).

eg MyClass Myobject[?];
or
MyClass *Myobject[?]

In VB you could simply have a Redim command

C++, 'new/delete' doesn't have that capability. You'd
need to allocate a new array of the new size, copy the
old array elements to it, then delete the old array.

where you preserve the existing
array and just add another index.

Do you need to go through contatiners?

You don't *have* to, but I reccomend it.

A container can be 'grown' or 'shrunk' as needs dictate.

-Mike

so using a container like vector is the standard way of a list of Objects of
unknown size....
also with containers is it more of a standard to hold the pointers to
objects or the objects themselves.

[Shan]

john townsley wrote:

"Mike Wahler" <mk******@mkwahler.net> wrote in message
news:Ih*****************@newsread3.news.pas.earthl ink.net...

"john townsley" <jo**********@optusnet.com.au> wrote in message
news:42**********************@news.optusnet.com.au ...

I want to know how can you have an array of objects declared if you dont know how many items will be in the array?
Allocate the array with operator 'new[]'
(and don't forget to deallocate it with
operator 'delete[]' when you're done with
the array.

But imo the superior alternative is to stop
using an array and use a container instead
(e.g. vector).

eg MyClass Myobject[?];
or
MyClass *Myobject[?]

In VB you could simply have a Redim command

C++, 'new/delete' doesn't have that capability. You'd
need to allocate a new array of the new size, copy the
old array elements to it, then delete the old array.

where you preserve the existing
array and just add another index.

Do you need to go through contatiners?

You don't *have* to, but I reccomend it.

A container can be 'grown' or 'shrunk' as needs dictate.

-Mike

so using a container like vector is the standard way of a list of

Objects of unknown size....
also with containers is it more of a standard to hold the pointers to objects or the objects themselves.

It is upto you to decide. The common way is to hold the objects
themselves.

[Richard Herring]

In message <11**********************@c13g2000cwb.googlegroups .com>, Shan
<sh*******@rediffmail.com> writes

john townsley wrote:

"Mike Wahler" <mk******@mkwahler.net> wrote in message
news:Ih*****************@newsread3.news.pas.earthl ink.net...

>
> "john townsley" <jo**********@optusnet.com.au> wrote in message
> news:42**********************@news.optusnet.com.au ...
>> I want to know how can you have an array of objects declared ifyou dont >> know how many items will be in the array?
>
> Allocate the array with operator 'new[]'
> (and don't forget to deallocate it with
> operator 'delete[]' when you're done with
> the array.
>
> But imo the superior alternative is to stop
> using an array and use a container instead
> (e.g. vector).
>
>>
>> eg MyClass Myobject[?];
>> or
>> MyClass *Myobject[?]
>>
>> In VB you could simply have a Redim command
>
> C++, 'new/delete' doesn't have that capability. You'd
> need to allocate a new array of the new size, copy the
> old array elements to it, then delete the old array.
>
>>where you preserve the existing
>> array and just add another index.
>
>
>>Do you need to go through contatiners?
>
> You don't *have* to, but I reccomend it.
>
> A container can be 'grown' or 'shrunk' as needs dictate.

so using a container like vector is the standard way of a list of

Objects of

unknown size....
Yes, but don't call it a "list", which is a different kind of container
;-)
also with containers is it more of a standard to hold the pointers to

objects or the objects themselves.

It is upto you to decide. The common way is to hold the objects
themselves.

.... provided they meet the container's requirements for contained
objects (basically, that you can take copies of them.)

--
Richard Herring

[red floyd]

Richard Herring wrote:

In message <11**********************@c13g2000cwb.googlegroups .com>, Shan
<sh*******@rediffmail.com> writes

john townsley wrote:

"Mike Wahler" <mk******@mkwahler.net> wrote in message
news:Ih*****************@newsread3.news.pas.earthl ink.net...
>
> "john townsley" <jo**********@optusnet.com.au> wrote in message
> news:42**********************@news.optusnet.com.au ...
>> I want to know how can you have an array of objects declared if

you dont

>> know how many items will be in the array?
>
> Allocate the array with operator 'new[]'
> (and don't forget to deallocate it with
> operator 'delete[]' when you're done with
> the array.
>
> But imo the superior alternative is to stop
> using an array and use a container instead
> (e.g. vector).
>
>>
>> eg MyClass Myobject[?];
>> or
>> MyClass *Myobject[?]
>>
>> In VB you could simply have a Redim command
>
> C++, 'new/delete' doesn't have that capability. You'd
> need to allocate a new array of the new size, copy the
> old array elements to it, then delete the old array.
>
>>where you preserve the existing
>> array and just add another index.
>
>
>>Do you need to go through contatiners?
>
> You don't *have* to, but I reccomend it.
>
> A container can be 'grown' or 'shrunk' as needs dictate.

so using a container like vector is the standard way of a list of

Objects of

unknown size....

Yes, but don't call it a "list", which is a different kind of container ;-)
also with containers is it more of a standard to hold the pointers to

objects or the objects themselves.

It is upto you to decide. The common way is to hold the objects
themselves.

... provided they meet the container's requirements for contained
objects (basically, that you can take copies of them.)

And that you don't need polymorphic behavior. If you need polymorphic
behavior, you have to use a container of (hopefully smart) pointers.

[Richard Herring]

In message <HR*****************@newssvr24.news.prodigy.net> , red floyd
<no*****@here.dude> writes

Richard Herring wrote:

In message <11**********************@c13g2000cwb.googlegroups .com>,
Shan <sh*******@rediffmail.com> writes

john townsley wrote:

"Mike Wahler" <mk******@mkwahler.net> wrote in message
news:Ih*****************@newsread3.news.pas.earthl ink.net...
>
> "john townsley" <jo**********@optusnet.com.au> wrote in message
> news:42**********************@news.optusnet.com.au ...
>> I want to know how can you have an array of objects declared if

you dont

>> know how many items will be in the array?
>
> Allocate the array with operator 'new[]'
> (and don't forget to deallocate it with
> operator 'delete[]' when you're done with
> the array.
>
> But imo the superior alternative is to stop
> using an array and use a container instead
> (e.g. vector).
>
>>
>> eg MyClass Myobject[?];
>> or
>> MyClass *Myobject[?]
>>
>> In VB you could simply have a Redim command
>
> C++, 'new/delete' doesn't have that capability. You'd
> need to allocate a new array of the new size, copy the
> old array elements to it, then delete the old array.
>
>>where you preserve the existing
>> array and just add another index.
>
>
>>Do you need to go through contatiners?
>
> You don't *have* to, but I reccomend it.
>
> A container can be 'grown' or 'shrunk' as needs dictate.

so using a container like vector is the standard way of a list of

Objects of

unknown size.... Yes, but don't call it a "list", which is a different kind of
container ;-)

also with containers is it more of a standard to hold the pointers

objects or the objects themselves.
It is upto you to decide. The common way is to hold the objects
themselves.

... provided they meet the container's requirements for contained
objects (basically, that you can take copies of them.)

And that you don't need polymorphic behavior.

That's implicit in the CopyConstructible requirement. A (base class)
copy of a derived object wouldn't be equivalent to it.
If you need polymorphic behavior, you have to use a container of
(hopefully smart) pointers.

Seconded.

--
Richard Herring

[Richard Herring]

In message <42**********************@news.optusnet.com.au>, john
townsley <jo**********@optusnet.com.au> writes

"Shan" <sh*******@rediffmail.com> wrote in message
news:11**********************@c13g2000cwb.googleg roups.com...

john townsley wrote:

"Mike Wahler" <mk******@mkwahler.net> wrote in message
news:Ih*****************@newsread3.news.pas.earthl ink.net...
>
> "john townsley" <jo**********@optusnet.com.au> wrote in message
> news:42**********************@news.optusnet.com.au ...
>> I want to know how can you have an array of objects declared if you dont

>> know how many items will be in the array?
>
> Allocate the array with operator 'new[]'
> (and don't forget to deallocate it with
> operator 'delete[]' when you're done with
> the array.
>
> But imo the superior alternative is to stop
> using an array and use a container instead
> (e.g. vector).
>
>>
>> eg MyClass Myobject[?];
>> or
>> MyClass *Myobject[?]
>>
>> In VB you could simply have a Redim command
>
> C++, 'new/delete' doesn't have that capability. You'd
> need to allocate a new array of the new size, copy the
> old array elements to it, then delete the old array.
>
>>where you preserve the existing
>> array and just add another index.
>
>
>>Do you need to go through contatiners?
>
> You don't *have* to, but I reccomend it.
>
> A container can be 'grown' or 'shrunk' as needs dictate.
>
> -Mike
>
>

so using a container like vector is the standard way of a list of

Objects of

unknown size....
also with containers is it more of a standard to hold the pointers to

objects or the objects themselves.

It is upto you to decide. The common way is to hold the objects
themselves.

i am confused, arent you wasting memory

Is memory rationed now? Don't worry about "wasting" it until you *know*
you have a problem.
by not declaring Pointers to Global
objects of unknown size? and simply declaring the instances and copy to
container?

I don't follow. Why are your objects of unknown size, and what do you
mean by "global" here?

If you mean you want a *heterogeneous* container of different sorts of
objects, not a single uniform type, then you can't directly store them
in a standard container. If they are polymorphic objects derived from a
common base class, store smart pointers. If they are some kind of data
tagged with type information, there are various kinds of "variant" class
that might fit the bill. If they are totally unrelated, why would you
want to keep them in the same container?

--
Richard Herring