Is it possible to pass an array into a function as a parameter without creating a variable for that array?

Question

So I made a function that takes arrays as parameters and I've tried calling the function by passing arrays that have not been defined as variables into said function (like {0,0,0,0}). However, I am given an error which says "too many initializer values."

Say we have a function defined as:

int func(int values[]) {
  int average = 0;
  for(int x = 0; x < values.size(); x++) {
    average += values[x];
  }
  return average / values.size();
}

And we want to call it without defining an array to pass in like this: func({1,6,7,2});

Is there any way to do something like this or would I have to define an array and pass it into the function that way?

Raindrop7 · Answer 1 · 2019-03-25T10:38:03.387

You cannot do that using built-in arrays. The fact that Arrays are neither Assignable nor Copy-able. Also They are not classes so they don't have member functions like size() or they take Initializer-list.

You can achieve that through using std::array if the size is constant or using std::vector if the size if dynamic.

#include <array>


int func(const std::array<int, 5>& values) { 

    int average = 0;
    for (size_t x{}, sz{ values.size() }; x != sz ; ++x)
        average += values[x];

    return average / values.size();
}



int main() {
    auto ret{
        func({ 1, 6, 7, 2 })
    };

    std::cout << ret << std::endl;
}

Also don't mix Unsigned with Signed in calculations like in your loop:

for(int x = 0; x < values.size(); x++) // x is int while values.size() is unsigned int.

int func(const std::array<int, 5>& values): pass by reference to avoid the copy especially if the size is big. Also pass by const as long as the function doesn't intend to change the parameter also another benefit of using const reference is you can pass literals instead of an object.
N.B: I recommend to also to use range-based for because it is really relevant in your example as long as you want to iterate over all the elements and not intending to insert nor to delete elements:
```
int average = 0;
for (const auto& e : values)
    average += e;
```

Another version of func as @M.M pointed out is to use std::accumalate to do the job for you:

int func(const std::array<int, 5>& values) {    
    return std::accumulate(values.begin(), values.end(), 0) /
        values.size();
}

This answer has worked for me, however when I have a 2D std::array in the parameters (like `{{ {"Character", "hello"} }}`) as well as a normal std::array, for some reason I get an error saying "cannot convert argument from initializer list to std::array. I will edit my post to include more details. — Cyerunix, Mar 24 '19 at 20:20
@CodyFG: Please ask another question instead. Because it is irrelevant to keep editing the topic. — Raindrop7, Mar 24 '19 at 21:24
@M.M: Yea I've pointed to that at the end of the answer. I made the loop variable `const auto&` as long as I don't extra copy and not changing the elements of the array. — Raindrop7, Mar 25 '19 at 10:26
OK. I'd not use reference since it is just an `int` we are talking about, but it is personal preference really — M.M, Mar 25 '19 at 11:21

score 3 · Answer 2 · answered Mar 24 '19 at 19:33

3

Using a vector, yes:

#include <vector>
using namespace std;

void f( const vector <int> & v ) {
}

int main() {
    f( {1,2,3,4} );
}

answered Mar 24 '19 at 19:33

@Rietty Not by doing `s/vector/array/` – Mar 24 '19 at 19:45

score 1 · Answer 3 · answered Mar 24 '19 at 19:40

Arrays don't work like that. When you pass an array to a function, the address of the first element gets passed like a pointer, and inside the function there is no more information about the size of the array. (Before the compiler itself could infer the size because the array was declared in the scope, but a function can be called from any number of places)

If you want to do something like that you would either have to use a container class, such as a vector, or you could pass a second argument into the function stating the size of the array. Another way is to have some sort of end point in your array, such as is the case with c-strings, for example a null value.

score 1 · Accepted Answer · answered Mar 05 '23 at 04:19

In fact you can pass an array into a function like that:

avg({1, 2, 3});

By using templates, in order to deduce the array size at compile-time.

Here is an example:

template<std::size_t N>
double avg(const int (&values)[N]) {
  double sum = 0;
  for(auto v: values) {
    sum += v;
  }
  return sum / N;
}

int main() {
    std::cout << avg({1, 2, 3});
}

Note that the function must take the array as const reference.

Is it possible to pass an array into a function as a parameter without creating a variable for that array?

4 Answers4