# Array sum in C++ STL

## Introduction:

C++ Standard Template Library (STL) is a collection of pre-defined classes and functions that make it easier to implement data structures and algorithms. One of the common operations in programming is to find the sum of elements in an array. In this article, we will discuss how to use the C++ STL library to calculate the sum of elements in an array.

## Creating an array:

First, we need to create an array. An array is a collection of elements of the same type. In C++, we declare arrays using the syntax "type array_name[size]". For example, to create an integer array of size 5, we can use the following code:

`Int arr[5];`

Alternatively, we can also initialize the array with values:

`Int arr[] = {1,2,3,4,5};`

## Using accumulate() function:

The accumulate() function is defined in the <numeric> header file of the C++ STL library. This function takes a range of elements as input and returns the sum of those elements. The syntax of accumulate() function is as follows:

`accumulate(start_iterator, end_iterator, initial_value)`

The start_iterator and end_iterator define the range of elements, and initial_value is the initial value of the sum.

For example, the following code calculates the sum of elements in an integer array using the accumulate() function:

``````#include <iostream>
#include <numeric>

int main()
{
int arr[] = {1, 2, 3, 4, 5};
int n = sizeof(arr) / sizeof(arr[0]);

int sum = std::accumulate(arr, arr + n, 0);

std::cout << "Sum of elements in the array: " << sum << std::endl;

return 0;
}``````

Explanation:

• In the main() function, we create an integer array called arr with 5 elements: 1, 2, 3, 4, and 5.
• We calculate the number of elements in the array n by dividing the size of the array by the size of its first element.
• We use the std::accumulate function from the numeric library to calculate the sum of the elements in the array.
• The std::accumulate function takes three arguments: the start of the array (in this case, arr), the end of the array (in this case, arr + n), and the initial value of the sum (in this case, 0).
• We store the sum of the elements in the array in the integer variable sum.
• We print the result to the console using the std::cout object and the << operator.

Program Output:

Example program:

Here's a more comprehensive example that prompts the user to enter the elements of an array and then calculate the sum using the C++ STL library.

``````#include <iostream>
#include <numeric>

int main()
{
const int MAX_SIZE = 100;

int arr[MAX_SIZE];
int n;

std::cout << "Enter the size of the array: ";
std::cin >> n;

if (n > MAX_SIZE || n < 1)
{
std::cout << "Invalid array size" << std::endl;
return 1;
}

std::cout << "Enter the elements of the array: ";

for (int i = 0; i < n; i++)
{
std::cin >> arr[i];
}

int sum = std::accumulate(arr, arr + n, 0);

std::cout << "Sum of elements in the array: " << sum << std::endl;

return 0;
}
``````

Explanation:

• The program declares a constant MAX_SIZE and an integer array arr of size MAX_SIZE. It also declares an integer variable, n, to store the size of the array.
• The user is prompted to enter the size of the array, and the program reads the value using std::cin.
• If the value entered is less than 1 or greater than MAX_SIZE, the program prints an error message and returns 1, indicating an error.
• If the value entered is valid, the program prompts the user to enter the elements of the array using a for loop that iterates n times. The values are stored in the array arr.
• The program then uses the std::accumulate function to calculate the sum of the elements in the array. This function takes three arguments: the beginning of the array, the end of the array (in this case, arr+n), and an initial value of 0.
• The program prints the sum of the elements to the console using std::cout.

Program Output:

## Conclusion:

In conclusion, C++ STL provides a simple and efficient way to calculate the sum of elements in an array using the accumulate() function. This function takes two iterators that define the range of elements to be summed and an initial value for the sum. The sum is calculated by iterating over the elements in the range and adding them to the initial value. The resulting sum is returned by the function.

Using the accumulate() function is straightforward and can significantly simplify the code required to calculate the sum of elements in an array. Additionally, the use of C++ STL algorithms can lead to more readable and maintainable code, as they abstract away the implementation details and focus on the algorithmic logic.

Overall, the accumulate() function in C++ STL is a powerful tool that can be used to perform array summation and other numerical calculations with ease.