How can you deduce the size of an array in a function template?

Question

I have a bunch of structs like:

struct A { ... }
struct B { ... }
struct C { ... }

I want to devise a function that can accept arrays of these structs and iterate through each element of the array and call another function like:

template <typename T>
ostream& process(ostream& os, const T* array) {
   // output each element of array to os (but how do we know the length?)
}

A a_array[10];
// in practice, this is actually operator<<, so I cannot pass in the
// size explicitly
process(..., a_array);

Update: I cannot use any of the std containers here. It has to be an array unfortunately!

Why are you not using std::vector or std::array?

Paul Manta
– Paul Manta

2012-01-04 17:08:49 +00:00
Commented Jan 4, 2012 at 17:08 — Paul Manta
– Paul Manta, Commented Jan 4, 2012 at 17:08

vallentin · Accepted Answer · 2016-10-14 04:52:34Z

10

Array-to-pointer decay is really, really bad.

Fortunately, C++ has array references, which know their size.

template<typename T, size_t N> ostream& process(ostream& os, const T (&arr)[N]) {
    // use N
}

edited Oct 14, 2016 at 4:52

vallentin

26.5k6 gold badges70 silver badges93 bronze badges

answered Jan 4, 2012 at 17:05

Puppy

147k40 gold badges271 silver badges481 bronze badges

Sign up to request clarification or add additional context in comments.

9 Comments

zneak Over a year ago

I've always seen const T (&arr)[N], but I suppose it works the same.

Puppy Over a year ago

I've no idea, it's been a really long time since I used that syntax.

CashCow Over a year ago

I think it is advantageous to drop the const. The template will automatically make the type const if it needs to be, but if you pass in a non-const array I seem to recall it won't know how to handle it.

Dietmar Kühl Over a year ago

The notation const T(&arr)[Size] definitely works to deduce the size of a statically sized array. Leaving off the const has the advantage that the constness is correctly deduced, e.g. when getting an end iterator for the array.

Puppy Over a year ago

@Dietmar: Oh noes! Code bloat! My binary, it might consume a couple more KB, compared to my hundreds of MB of art and such.

|

Fox32 · Accepted Answer · 2012-01-04 17:18:54Z

7

You could use a std::vector<T> instead of an simple array.

template <typename T>
ostream& process(ostream& os, const std::vector<T> &array) {
   for(std::vector<T>::const_iterator iterator = array.begin(); iterator != array.end(); ++iterator)
   {
      //...
   }
}

Or you can go the std::array way (If your compiler support it and N is constant).

template <typename T, int N>
ostream& process(ostream& os, const std::array<T, N> &array) {
   for(std::array<T, N>::const_iterator iterator = array.begin(); iterator != array.end(); ++iterator)
   {
      //...
   }
}

// Usage:
array<int, 10> test;
process(..., test);

edited Jan 4, 2012 at 17:18

answered Jan 4, 2012 at 17:07

Fox32

13.7k9 gold badges54 silver badges71 bronze badges

2 Comments

user142019 Over a year ago

why not std::array<T, N>? The size is known and constant.

Grizzly Over a year ago

If the compiler doesn't have std::array, boost::array is always an option

moshbear · Accepted Answer · 2012-01-06 09:02:33Z

2

You need to use the following format for arrays:

template <typename T, size_t N>
void foo(const T (&arr)[N]) {
    ...
}

Otherwise, size information will be lost.

answered Jan 6, 2012 at 9:02

moshbear

3,3321 gold badge23 silver badges33 bronze badges

Comments

DYoung · Accepted Answer · 2012-01-04 17:39:29Z

Or, a simple template bounds checked array.

template< typename T, unsigned int Size >
class Array
{
    public:

    T& operator[]( unsigned int index )
    {
       assert( index < Size );
       return mElements[ index ];
    }

    const T& operator[]( unsigned int index ) const
    {
       assert( index < Size );
       return mElements[ index ];
    }

    unsigned int Capacity() const
    {
        return Size;
    }

    private:
        T mElements[ Size ];
};

And then

template< typename T, unsigned int Size >
void Process( Array< T, Size >& array )
{
    for( unsigned int i = 0; i < Size; ++i )
    {
        //use array[i]
    }
}

And to tie it together

Array< int, 10 > array;
Process( array );

It's a bit of a roll your own solution, but it's probably roughly equivalent (although a less functional array class) to std::Array or boost

Collectives™ on Stack Overflow

How can you deduce the size of an array in a function template?

4 Answers 4

9 Comments

2 Comments

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

4 Answers 4

9 Comments

2 Comments

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related