Velocity Reviews - Computer Hardware Reviews

Velocity Reviews > Newsgroups > Programming > C++ > size of an array at runtime?

Reply
Thread Tools

size of an array at runtime?

 
 
aaragon
Guest
Posts: n/a
 
      06-28-2008
Hello everyone,

I was wondering if there is a way to determine the size of an array at
runtime. Let's say I have a class that has one of its constructors
taking an array:

template <class T>
class A {

// constructors
....
A(const T array[]) {
// use array
}
// other fns...
};

So of course I cannot use the sizeof operator because the array can be
created at runtime, so sizeof(array)/sizeof(array[0]) won't work. Now,
operator delete[] can still figure the size of an array, right?
Therefore, there has to be a way to determine the size of it.

Thanks for viewing my post.

aa
 
Reply With Quote
 
 
 
 
Kai-Uwe Bux
Guest
Posts: n/a
 
      06-28-2008
aaragon wrote:

> Hello everyone,
>
> I was wondering if there is a way to determine the size of an array at
> runtime. Let's say I have a class that has one of its constructors
> taking an array:
>
> template <class T>
> class A {
>
> // constructors
> ...
> A(const T array[]) {
> // use array
> }
> // other fns...
> };
>
> So of course I cannot use the sizeof operator because the array can be
> created at runtime, so sizeof(array)/sizeof(array[0]) won't work. Now,
> operator delete[] can still figure the size of an array, right?


It only has to if T has a non-trivial destructor. Otherwise, delete[] only
needs to figure out how much memory needs to be released. That only gives
an upper bound for the size. E.g., if you allocate 116 chars, the actual
memory allocated may very well be 128 bytes; and delete only needs to know
that these 128 bytes are now freed.

> Therefore, there has to be a way to determine the size of it.


(a) non sequitur: even assuming that delete [] knows the number of elements
in the array, there does not need to be a language mechanism that allows
you to get at that piece of information. And as far as I can tell, there
happen to not to be such a mechanism.

(b) If you need that information, the easiest way is to use std::vector. If
you really want to use arrays, the only way to get the length is to not
forget it: when you new[] the array, you know the length; just don't throw
away that piece of information.


Best

Kai-Uwe Bux
 
Reply With Quote
 
 
 
 
James Kanze
Guest
Posts: n/a
 
      06-29-2008
On Jun 28, 9:52 pm, Kai-Uwe Bux <(E-Mail Removed)> wrote:
> aaragon wrote:
> > I was wondering if there is a way to determine the size of
> > an array at runtime. Let's say I have a class that has one
> > of its constructors taking an array:


> > template <class T>
> > class A {


> > // constructors
> > ...
> > A(const T array[]) {
> > // use array
> > }
> > // other fns...
> > };


> > So of course I cannot use the sizeof operator because the
> > array can be created at runtime, so
> > sizeof(array)/sizeof(array[0]) won't work. Now, operator
> > delete[] can still figure the size of an array, right?


[...]
> > Therefore, there has to be a way to determine the size of it.


[...]
> (b) If you need that information, the easiest way is to use
> std::vector. If you really want to use arrays, the only way to
> get the length is to not forget it: when you new[] the array,
> you know the length; just don't throw away that piece of
> information.


If the arrays are dynamically allocated (as his mention of
delete[] suggests), then he definitely should be using
std::vector. If they're not, of course, something like:

template< typename T >
class A
{
template< size_t N >
Array( T const (&array)[ N ] ) ...
} ;

can also be used.

(More generally, if he wants to support both, it should probably
be:

template< typename ForwardIterator >
Array( ForwardIterator begin, ForwardIterator end ) ;

He can then use the de facto standard begin and end:

template< typename T, size_t N >
T*
begin( T (&array)[ N ] )
{
return array ;
}

template< typename T, size_t N >
T*
end( T (&array)[ N ] )
{
return array + N ;
}

to invoke this constructor with a C style array.)

--
James Kanze (GABI Software) email:(E-Mail Removed)
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34
 
Reply With Quote
 
Rolf Magnus
Guest
Posts: n/a
 
      06-29-2008
aaragon wrote:

> Hello everyone,
>
> I was wondering if there is a way to determine the size of an array at
> runtime. Let's say I have a class that has one of its constructors
> taking an array:
>
> template <class T>
> class A {
>
> // constructors
> ...
> A(const T array[]) {
> // use array
> }
> // other fns...


That constructor isn't taking an array, but rather a pointer in disguise.
It's 100% equivalent to:

A(const T* array) {
// use array
}

> };
>
> So of course I cannot use the sizeof operator because the array can be
> created at runtime, so sizeof(array)/sizeof(array[0]) won't work.


That operation will work, but it won't give you the result you want, because
you're doing it on a pointer, not an array. This doesn't have anything to
do with how your array got created.

> Now, operator delete[] can still figure the size of an array, right?
> Therefore, there has to be a way to determine the size of it.


The only way of determining it is by remembering it.

 
Reply With Quote
 
aaragon
Guest
Posts: n/a
 
      06-30-2008
On Jun 29, 5:16 am, Rolf Magnus <(E-Mail Removed)> wrote:
> aaragon wrote:
> > Hello everyone,

>
> > I was wondering if there is a way to determine the size of an array at
> > runtime. Let's say I have a class that has one of its constructors
> > taking an array:

>
> > template <class T>
> > class A {

>
> > // constructors
> > ...
> > A(const T array[]) {
> > // use array
> > }
> > // other fns...

>
> That constructor isn't taking an array, but rather a pointer in disguise.
> It's 100% equivalent to:
>
> A(const T* array) {
> // use array
> }
>
> > };

>
> > So of course I cannot use the sizeof operator because the array can be
> > created at runtime, so sizeof(array)/sizeof(array[0]) won't work.

>
> That operation will work, but it won't give you the result you want, because
> you're doing it on a pointer, not an array. This doesn't have anything to
> do with how your array got created.
>
> > Now, operator delete[] can still figure the size of an array, right?
> > Therefore, there has to be a way to determine the size of it.

>
> The only way of determining it is by remembering it.


Thank you for your answers...
 
Reply With Quote
 
 
 
Reply

Thread Tools

Posting Rules
You may not post new threads
You may not post replies
You may not post attachments
You may not edit your posts

BB code is On
Smilies are On
[IMG] code is On
HTML code is Off
Trackbacks are On
Pingbacks are On
Refbacks are Off


Similar Threads
Thread Thread Starter Forum Replies Last Post
Preferred Size, Minimum Size, Size Jason Cavett Java 5 05-25-2008 08:32 AM
mega pixels, file size, image size, and print size - Adobe Evangelists Frank ess Digital Photography 0 11-14-2006 05:08 PM
Could a struct with size 44 bytes point always points to a char array with size 2024 bytes? eagle_jyjh@citiz.net C++ 8 04-10-2006 03:05 PM
Could a struct with size 44 bytes point always points to a char array with size 2048 bytes? eagle_jyjh@citiz.net C Programming 5 04-09-2006 02:49 PM
On template method to obtain the size of an array. Was: [OT] Re: 2 stupid array questions!! Zygmunt Krynicki C++ 1 10-11-2003 01:18 AM



Advertisments