Modern C++ array arguments

Question

I would like to pass small arrays of variable size as parameters in modern C++, ie:

func({1,2,3,4});

And it should be as fast as possible, ideally without heap allocation.

Things I've tried:

C style array

void func(int * arr, int arrayCount) {
   for (int i = 0; i < arrayCount; i++) {
      //use arr[i];
   }
}

int arr[] = {1,2,3,4};
func(arr, 4);

This is fast and efficient, but adds an extra arrayCount variable which is prone to user error, and the function call is now broken into two lines.

std vector

void func(vector<int> arr) {
    for (int &a : arr) {
      //use a
    }
}

func({1,2,3});

This is very clean but it's remarkably slow due to copying data over to the heap. Changing the signature to use a universal ref:

void func(vector<int> && arr) {

Doesn't seem to make any difference.

std initializer_list

void func(initializer_list<int> arr) {
    for (int &a : arr) {
      //use a
    }
}

func({1,2,3});

This is a 50x speed improvement over the vector (approximately)! Using a && again makes no difference, but it is still (approximately) 5-10x slower than the C style syntax due to the overhead of initializer_list creation and iteration. Still acceptable for many use cases, but the overhead seems a little unnecessary.

Thinking maybe compilers had gotten smarter, I tried the following:

std array

template <int arrayCount>
void func(array<int, arrayCount> arr) {

  for (int &a : arr) {
    //use a
  }

}

The compiler can not infer the size from the call, so it is necessary to write

func<3>({1,2,3});

And in any case, this is no faster than the initializer list.

Variadic templates are out of the question for a number of reasons, because they don't support multiple array parameters and the syntax is difficult to navigate.

Is there a way to get both clean syntax and fast performance? It seems like it would be easy to add some syntactic sugar to wrap the C style array notation.

---

Clarification:

These tests were performed in MSVC 2017 with default optimization (O2):

timer.start();
for(int i = 0; i < 100000; i++) {
   func({i, i+2, i+3, i+4});
}
timer.stop();

or for the c style:

for (int i = 0; i < 100000; i++) {
   int arr[] = {i, i+2, i+3, i+4};
   func(arr, 4);
}

With the passed in values being added to a static variable.

---

Review:

See Robert's answer below for the syntax for passing arrays using generics that avoids STL and has similar performance to the C style option, but is limited in its ability to handle empty arrays.

My take away is that the initalizer_list notation is probably fast enough in most use cases, the vector notation should be avoided, and when performance is absolutely critical, consider the generic array approach or C style arrays depending on the use case. MSVC doesn't optimize these as well as GCC/Clang.

Answer 1

Try this :

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

void func() // overloaded function for empty parameter
{...}

The compiler will automatically deduce the type and array size from the array passed into the function. The array has to be a complete type - not a pointer and dimension has to be known at call location.

---

Edit: If a function with no parameters cannot be used, then tag-dispatching should be considered:

class Empty_List {};

static constexpr Empty_List empty;

void func( Empty_List ) 
{ ... }

which should be called:

 func( empty ); // option 1
 func( {} );    // option 2

Answer 2

With C++17 it is easy enough to replace small arrays like this by variadic non-type templates. It might be worth considering something like:

template <std::size_t... Ns>
using A = std::index_sequence<Ns...>; // syntactic sugar

template <std::size_t... Ns>
constexpr void func(A<Ns...>) {
    (do_something(Ns), ...); // fold expression <=> for (int a: arr)
}

Answer 3

A common idiom in C++ is a span, sometimes called a slice, a ref, or a view, as in array_view, string_view, etc. Effectively, it's a bundling of the pointer and size arguments you used in the C-style array case, but in a C++ class that gives a std::array or std::vector interface. It's a non-owning reference to the data held in another contiguous container. Some implementations use spans only for const references but others do not.

The idiom gives you identical code to your std::vector case, but it's as efficient as the C-style array case because there's no dynamic memory allocation and copying.

The idiom has become so common, that it's part of the C++ Core Guidelines support library and a version may even make it into the C++ standard library.

If you don't have a library that already provides this idiom, it's not too hard to roll your own. You create a class template that has, as member, the pointer and the count of elements. You add constructors that make it easy to convert containers to this representation, and you overload operator[] to provide access.