How do I Pass an array object (Class Template c++) to a function as a parameter?

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.