size of an array at runtime?

Discussion in 'C++' started by aaragon, Jun 28, 2008.

  1. aaragon

    aaragon Guest

    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
    aaragon, Jun 28, 2008
    #1
    1. Advertising

  2. aaragon

    Kai-Uwe Bux Guest

    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
    Kai-Uwe Bux, Jun 28, 2008
    #2
    1. Advertising

  3. aaragon

    James Kanze Guest

    On Jun 28, 9:52 pm, Kai-Uwe Bux <> 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:
    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
    James Kanze, Jun 29, 2008
    #3
  4. aaragon

    Rolf Magnus Guest

    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.
    Rolf Magnus, Jun 29, 2008
    #4
  5. aaragon

    aaragon Guest

    On Jun 29, 5:16 am, Rolf Magnus <> 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...
    aaragon, Jun 30, 2008
    #5
    1. Advertising

Want to reply to this thread or ask your own question?

It takes just 2 minutes to sign up (and it's free!). Just click the sign up button to choose a username and then you can ask your own questions on the forum.
Similar Threads
  1. sunny_rao

    change array size at runtime

    sunny_rao, Apr 15, 2005, in forum: C Programming
    Replies:
    10
    Views:
    1,714
    Keith Thompson
    Apr 17, 2005
  2. Replies:
    5
    Views:
    528
    Flash Gordon
    Apr 9, 2006
  3. sunny
    Replies:
    5
    Views:
    2,108
    CBFalconer
    Aug 17, 2006
  4. Stefano Sabatini
    Replies:
    9
    Views:
    371
    terminator
    Dec 4, 2007
  5. Jason Cavett

    Preferred Size, Minimum Size, Size

    Jason Cavett, May 23, 2008, in forum: Java
    Replies:
    5
    Views:
    12,558
    Michael Jung
    May 25, 2008
Loading...

Share This Page