shorthand std::array literal parameter - c++

Question

I've been trying to write some shorter code that still uses std::array but I'm not sure how to get the deduction to work in my favor.
Is there a way to write this that is equally as short(readable) as the vector version?
#include <array>
#include <iostream>
#include <vector>
template <std::size_t SIZE>
void afunc(const std::array<std::string_view, SIZE> &v)
{
for(int i=0; i<10; i++)
{
std::cout << v[rand()%SIZE];
}
}
void vfunc(const std::vector<std::string_view> &v)
{
for(int i=0; i<10; i++)
{
std::cout << v[rand()%v.size()];
}
}
using namespace std::string_view_literals;
int main()
{
std::array<std::string_view, 2> works = {"1","2"};
afunc(works);// verbose
//afunc({ "1","2" }); // 1st fail
//afunc({ "1"sv,"2"sv }); // 2nd fail
//afunc(std::array{ "3","4" });// 3rd fail
afunc(std::array{ "3"sv,"4"sv, "test"sv,"other"sv });// works but verbose
vfunc({"5","6", "7"});// vectors are easy to code with
return 0;
}

Answer 1

std::array and std::vector have the same size() and operator[] members, so you could roll your 2 functions into 1 function:
template <typename Container>
void func(const Container &c)
{
for(int i = 0; i < 10; ++i)
{
std::cout << c[rand() % c.size()];
}
}
std::array<std::string_view, 2> a{"1","2"};
func(a);
std::vector<std::string_view> v{"1","2"};
func(v);
func<std::array<std::string_view, 2>>({"1","2"});
func<std::vector<std::string_view>>({"1","2"});
Demo
But, as you can see, that can be too verbose for your taste. But, you can support braced lists as a parameter without having to specify the template argument explicitly, by defining an extra function that accepts std::initializer_list as a parameter, and then the compiler can deduce that parameter for you.
But, std::initializer_list doesn't have operator[], so you would have to change your main function logic to use random-access iterators instead, if you intend to share common code between the functions, eg:
template <typename Iter>
void func(Iter begin, Iter end, std::random_access_iterator_tag)
{
size_t size = end - begin;
for(int i = 0; i < 10; ++i)
{
std::cout << *(begin + (std::rand() % size));
}
}
template <typename Iter>
void func(Iter begin, Iter end)
{
func(begin, end,
typename std::iterator_traits<Iter>::iterator_category());
}
template <typename Container>
void func(const Container &c)
{
func(std::begin(c), std::end(c));
}
template <typename T>
void func(const std::initializer_list<T> &l)
{
func(l.begin(), l.end());
}
std::array<std::string_view, 2> a{"1","2"};
func(a);
std::vector<std::string_view> v{"1","2"};
func(v);
func({"1"sv, "2"sv});
Demo

Answer 2

You can't infer a compile-time size from an initializer list parameter, so you need to pass the size explicitly:
template <std::size_t Size>
void afunc(const std::array<std::string_view, Size> &v)
{ ... }
int main()
{
afunc<2>({ "1", "2" }); // ok
}
Your vfunc for std::vector doesn't need to deduce a compile-time size, which is why this limitation only applies to template argument deduction for std::array in afunc.

Answer 3

Found out how to get C style arrays to work as an option. When I had tried this before my reference was not const thus would not compile with a temporary. Not as good as arrays for the lack of iterators but still straightforward
template<size_t N>
void carr_try(std::string_view const(&a)[N])
{
for(int i=0; i<10; i++)
{
std::cout << a[rand()%N];
}
}
// for illustrative purposes of how to NOT write this routine
template<size_t N>
void nonconst(std::string_view (&a)[N])
{
for(int i=0; i<10; i++)
{
std::cout << a[rand()%N];
}
}
int main()
{
carr_try({ "1", "2" }); // ok
//nonconst({"1","2"});// not ok
std::string_view temp[]={"3","4"};
nonconst(temp);// is fine but long
}