Program in C++ that takes 3 numbers and send them to a function and then calculate the average function of these 3 numbers

Question

Program in C++ that takes 3 numbers and send them to a function and then calculate the average function of these 3 numbers.

---

I know how to do that without using a function ,for example for any n numbers I have the following program:

#include<stdio.h>

int main()
{


    int n, i;
    float sum = 0, x;

    printf("Enter number of elements:  ");
    scanf("%d", &n);
    printf("\n\n\nEnter %d elements\n\n", n);
    for(i = 0; i < n; i++)
    {
        scanf("%f", &x);
        sum += x;
    }
    printf("\n\n\nAverage of the entered numbers is =  %f", (sum/n));

    return 0;
}

Or this one which do that using arrays:

#include <iostream>
using namespace std;

int main()
{
    int n, i;
    float num[100], sum=0.0, average;

    cout << "Enter the numbers of data: ";
    cin >> n;

    while (n > 100 || n <= 0)
    {
        cout << "Error! number should in range of (1 to 100)." << endl;
        cout << "Enter the number again: ";
        cin >> n;
    }

    for(i = 0; i < n; ++i)
    {
        cout << i + 1 << ". Enter number: ";
        cin >> num[i];
        sum += num[i];
    }

    average = sum / n;
    cout << "Average = " << average;

    return 0;
}

---

But is it possible to use functions?if yes then how? thank you so much for helping.

Answer 1

As an alternative to using fundamental types to store your values C++ provides std::vector to handle numeric storage (with automatic memory management) instead of plain old arrays, and it provides many tools, like std::accumulate. Using what C++ provides can substantially reduce your function to:

double avg (std::vector<int>& i)
{
    /* return sum of elements divided by the number of elements */
    return std::accumulate (i.begin(), i.end(), 0) / static_cast<double>(i.size());
}

In fact a complete example can require only a dozen or so additional lines, e.g.

#include <iostream>
#include <vector>
#include <numeric>

double avg (std::vector<int>& i)
{
    /* return sum of elements divided by the number of elements */
    return std::accumulate (i.begin(), i.end(), 0) / static_cast<double>(i.size());
}

int main (void) {

    int n;                                          /* temporary integer */
    std::vector<int> v {};                          /* vector of int */

    while (std::cin >> n)                           /* while good integer read */
        v.push_back(n);                             /* add to vector */

    std::cout << "\naverage: " << avg(v) << '\n';   /* output result */
}

Above, input is taken from stdin and it will handle as many integers as you would like to enter (or redirect from a file as input). The std::accumulate simply sums the stored integers in the vector and then to complete the average, you simply divide by the number of elements (with a cast to double to prevent integer-division).

Example Use/Output

$ ./bin/accumulate_vect
10
20
34
done

average: 21.3333

(note: you can enter any non-integer (or manual EOF) to end input of values, "done" was simply used above, but it could just as well be 'q' or "gorilla" -- any non-integer)

It is good to work both with plain-old array (because there is a lot of legacy code out there that uses them), but equally good to know that new code written can take advantage of the nice containers and numeric routines C++ now provides (and has for a decade or so).

Answer 2

This is an example meant to give you an idea about what needs to be done. You can do this the following way:

// we pass an array "a" that has N elements
double average(int a[], const int N)
{
    int sum = 0;
    // we go through each element and we sum them up
    for(int i = 0; i < N; ++i)
    {
        sum+=a[i];
    }
    // we divide the sum by the number of elements
    // but we first have to multiply the number of elements by 1.0
    // in order to prevent integer division from happening
    return sum/(N*1.0);
}

int main() 
{
    const int N = 3;
    int a[N];

    cin >> a[0] >> a[1] >> a[2];

    cout << average(a, N) << endl;

    return 0;
}

Answer 3

So, I created two options for you, one use vector and that's really comfortable because you can find out the size with a function-member and the other with array

#include <iostream>
#include <vector>

float average(std::vector<int> vec)
{
    float sum = 0;
    for (int i = 0; i < vec.size(); ++i)
    {
        sum += vec[i];
    }
    sum /= vec.size();
    return sum;
}
float average(int arr[],const int n)
{
    float sum = 0;
    for (int i = 0; i < n; ++i)
    {
        sum += arr[i];
    }
    sum /= n;
    return sum;
}
int main() {
    std::vector<int> vec = { 1,2,3,4,5,6,99};
    int arr[7] = { 1,2,3,4,5,6,99 };
    std::cout << average(vec) << " " << average(arr, 7);
}

Answer 4

how to do that without using a function

Quite simple. Just put your code in a function, let's call it calculateAverage and return the average value from it. What should this function take as input?

• The list of numbers (array of numbers)
• Total numbers (n)

So let's first get the input from the user and put it into the array, you have already done it:

    for(int i = 0; i < n; ++i)
    {
        cout << i + 1 << ". Enter number: ";
        cin >> num[i];
    }

Now, lets make a small function i.e., calculateAverage():

int calculateAverage(int numbers[], int total)
{
    int sum = 0; // always initialize your variables
    for(int i = 0; i < total; ++i)
    {
        sum += numbers[i];
    }

    const int average = sum / total; // it is constant and should never change
                                     // so we qualify it as 'const'
    //return this value
    return average
}

There are a few important points to note here.

• When you pass an array into a function, you will loose size information i.e, how many elements it contains or it can contain. This is because it decays into a pointer. So how do we fix this? There are a couple of ways,
  • pass the size information in the function, like we passed total
  • Use an std::vector (when you don't know how many elements the user will enter). std::vector is a dynamic array, it will grow as required. If you know the number of elements beforehand, you can use std::array

A few problems with your code:

using namespace std;

Don't do this. Instead if you want something out of std, for e.g., cout you can do:

using std::cout
using std::cin
...

or you can just write std::cout everytime.

    int n, i;
    float num[100], sum=0.0, average;

Always initialize your variables before you use them. If you don't know the value they should be initialized to, just default initialize using {};

    int n{}, i{};
    float num[100]{}, sum=0.0, average{};

It is not mandatory, but good practice to declare variables on separate lines. This makes your code more readable.