如何推断函数模板中数组的大小？

Question

我有一堆结构，例如：

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

我想设计一个函数，它可以接受这些结构的数组并迭代数组的每个元素并调用另一个函数，例如：

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);

更新：我不能在这里使用任何标准容器。不幸的是它必须是一个数组！

Answer 1

数组到指针的衰减是真的，真的很糟糕。

幸运的是，C++ 有数组引用，它知道它们的大小。

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

Answer 2

您可以使用

std::vector<T>

而不是简单的数组。

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)
   {
      //...
   }
}

或者你可以采用 std::array 方式（如果你的编译器支持它并且 N 是常量）。

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);

Answer 3

您需要对数组使用以下格式：

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

否则尺寸信息将会丢失。

Answer 4

或者，一个简单的模板边界检查数组。

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 ];
};

然后

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

并将其绑在一起

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

这有点像你自己的解决方案，但它可能与 std::Array 或 boost 大致等效（尽管功能较少的数组类）