How can I solve this problem with arrays in C++?

Question

I am working on the Edabit challenge: Get arithmetic mean of the given array. Now I have code like that:

#include <iostream>
int data;
using namespace std;
int mean(int data);
int main()
{
    int data[] = { 1, 2, 3, 4 };
    cout << mean(data);
}
int mean(int data)
{
    double mean = 0;
    for (int i = 0; i < sizeof(data) / sizeof(data[0]); i++)
    {
        mean += data[i];
    }
    mean /= sizeof(data) / sizeof(data[0]);
}

and I am stuck. I use Visual Studio 2019 on Windows 7 Professional, and I have underlined 3 characters ( data[i], and 2x data[0]). For this x Visual Studio says expression must have pointer-to-object type (Error E0142) and I have no idea what it means with this. I only know what pointer is.

---

In Visual studio I added the return statement, but while shortening the code here for publishing I forgot to add it. Otherwise, this wasn't the actual problem. Now I mustn't add it in the question because the comments would be wrong. The comments are related to the upper question, but my real question (for future readers stuck on this problem) is rather:

How to pass array as an argument in the function.

Now, that I am more proficient in C++, I know the terminology and how to state it, and I also know that this isn't so clear to a total beginner: you can't just write f(int[] arr) (you can't pass arrays), but you have to write f(int* arr) (you can pass a pointer that points on that array). At that time I couldn't just search it because I didn't know much of C++ terminology.

Answer 1

Your mean function, well, is mean.
1. It doesn't return a value; there is no return statement.
2. It uses variable name the same as the function (not a recommended coding style).
3. There is a global variable data that is hidden by a local variable data inside main .
4. You're confusing the compiler and the reader: the global data variable is a single int . The local variable in main is an array of int .

You should have the last line be:
return mean;

Answer 2

Arrays decay into pointers (an int* in this case) when passed as argument to functions. Your mean function only accepts one single int .

When the array decays into a pointer the size information is lost. You can however prevent that by defining a function that accepts arrays of the exact type and size you need. This can be done with templates:

#include <iostream>

template<typename T, size_t N>
double mean(const T (&data)[N]) {
    double sum = 0;
    for (size_t i = 0; i < N; ++i)
    {
        sum += data[i];
    }
    return sum / N;
}

int main()
{
    int input[] = { 1, 2, 3, 4, 5, 6, 7 };
    std::cout << mean(input) << '\n';
}

If you don't want to use templates (or only accept arrays of a certain size), you need to pass the size information on to the function manually:

#include <iostream>
#include <iterator> // std::size

double mean(const int* data, size_t N)
{
    double sum = 0;
    for (size_t i = 0; i < N; ++i)
    {
        sum += data[i];
    }
    return sum / N;
}

int main()
{
    int input[] = { 1, 2, 3, 4, 5, 6, 7 };
    std::cout << mean(input, std::size(input)) << '\n';
}