如何将数组对象（Class Template c ++）作为参数传递给函数？

Question

If I declare an array (using c++ Class Template) like this,

#include <array> //standard c++ library
 int main()
{
 array<int,3> myarray{10,20,30}; 
}

How will I be able to send this array object to a function as a parameter.

If I pass like this it works :

void f_print(array<int, 3> object){}
int main()
{
 array<int, 3> myarray{10,20,30};
 f_print(myarray);
}

but the problem here is I am hard coding the size in the function. The whole point to work like this to use array as an object type so I can use array.size(). So How can I pass this array type object (c++ Class Template) without hardcoding the size.

Edit_1: Why can't I send the array object as only an object where I use all the properties of the object inside the function parameter.

Answer 1

You can template either the array type

template<typename T>
void f_print(std::array<T, 3> const& object);

Or the size

template<size_t S>
void f_print(std::array<int, S> const& object);

Or both:

template<typename T, size_t S>
void f_print(std::array<T, S> const& object);

The compiler should be able to deduce the correct template arguments in all the cases.

Answer 2

Make the function a template to avoid hard coding it for the size:

template<size_t S>
void f_print(array<int, S> object){}

See a Live Demo .

Answer 3

I think you are missing the point of arrays. It's in the very nature of an array that its size belongs to its type . That's the case for raw arrays and it's the case for std::array as well. Hard-coding the size 3 of std::array<int, 3> in the function is as unavoidable as hard-coding the int .

In fact, in my experience, the best way to think about an array like for example int[4] or std::array<int, 4> is as a shorthand for int a, b, c, d .

I'd say a template only circumvents the issue in a very superficial way. If you create a template with a size parameter, then you only end up with a lot of different functions for different array types. std::array<int, 3> , std::array<int, 4> , std::array<int, 5> and so on all result in different template instantiations. It's in the same way as you end up with different template instantiations for std::array<int, 3> , std::array<double, 3> and std::array<std::string, 3> .

Mind that turning the size into a template parameter may still be the solution you are actually looking for. If, however, you need a container for which the size is not known at compile time, then use std::vector .