size of an array at runtime?

[aaragon]

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

 

[Kai-Uwe Bux]

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

 

[James Kanze]

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?

[...]
[...]

(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.)

 

[Rolf Magnus]

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.

 

[aaragon]

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