如何在C++中将数组中的所有数字相加

这是在C++中执行此操作的惯用方法：

int a[] = {1, 3, 5, 7, 9};
int total = accumulate(begin(a), end(a), 0, plus<int>());

请注意，此示例假设您在某个地方：

#include <numeric>
using namespace std;

另请参阅：累积文档和累积演示。

假设您有一个int array[N]。

您可以简单地执行以下操作：

int sum = 0;
for(auto& num : array)
    sum += num;

试试这个：

int array[] = {3, 2, 1, 4};
int sum = 0;
for (int i = 0; i < 4; i++) {
    sum = sum + array[i];
}
std::cout << sum << std::endl;

如果你使用 valarray ，有一个成员函数sum()。

#include <iostream>     // std::cout
#include <valarray>     // std::valarray
int main () {
  std::valarray<int> myvalarray(4);
  myvalarray[0] = 0;
  myvalarray[1] = 10;
  myvalarray[2] = 20;
  myvalarray[3] = 30;
  std::cout << "The sum is " << myvalarray.sum() << 'n';
  return 0;
}

我能看到的最简单的方法是使用循环。好处是您可以在任何整数数组上使用它，而无需重写太多代码。我更频繁地使用Java，所以我希望没有太多的语法错误，但这样的事情应该可以工作：

int addArray(int[] array, int length){
    int sum=0;
    for(int count=0;count<length;count++){
        sum+=array[count];
    }
    return sum;
}

在 C++17 中，可以使用折叠表达式：

template<typename ...Ts>
int sum_impl(Ts&& ...a)
{
    return (a + ...);
}

如果sum_impl有一个恒定数量的参数，我们可以这样称呼它：

std::apply(sum_impl, arr);

假设 arr 是std::array<int, N> .但由于它是可变的，它需要帮助者一点推动：

using namespace std;
template <class Array, size_t... I>
int sum_impl(Array&& a, index_sequence<I...>)
{
        return sum_impl(get<I>(forward<Array>(a))...);
}
template <class Array>
int sum(Array&& a)
{
        return sum_impl(forward<Array>(a),
                        make_index_sequence<tuple_size_v<decay_t<Array>>>{});
}

因此，假设这些帮助程序已到位，代码将如下所示：

template<typename ...Ts>
int sum_impl(Ts&& ...a)
{
    return (a + ...);
}
int main()
{
    array<int, 10> arr{0,1,2,3,4,5,6,7,8,9};
    cout << sum(arr) << "n";
    return 0;
}

我们可以使用用户定义的函数。

代码片段：

#include<bits/stdc++.h>
using namespace std;

int sum(int arr[], int n)
{
    int sum=0;
    for(int i=0; i<n; i++)
    {
        sum += arr[i];
    }
    return sum;
}

int main()
{
  int arr[] = {1, 2, 3, 4, 5};
  int n = distance(begin(arr), end(arr));
  int total = sum(arr,n);
  printf("%d", total);
  return 0;
}

int Sum;
for(int& S: List) Sum += S;

如果您的编译器支持 c++17，则可以结合使用参数包和折叠表达式来实现此目的。模板参数包是接受零个或多个模板参数的模板参数，折叠通过二元运算符减少参数包。（在这种情况下+）

#include <iostream>
#include <array>
#include <utility>
/* 
 * References:
 *   [1] https://en.cppreference.com/w/cpp/language/fold
 *   [2] https://en.cppreference.com/w/cpp/language/parameter_pack
 */

template <typename ...T>
auto sum(T ...args)
{
    return (args + ...);
}
template <typename T, std::size_t ...Is>
auto sum(T t, std::index_sequence<Is...>)
{
    return sum(t[Is]...);
}
int main()
{
    std::array<int, 3> a1 = {1, 4, 3};
    int a2[5] = {1, 2, 3, 4, 0};
    std::cout << "Sum a1 = " << sum(a1, std::make_index_sequence<a1.size()>{}) << "n";
    std::cout << "Sum a2 = " << sum(a2, std::make_index_sequence<5>{}) << "n";
    return 0;
}

关于 std：：累积用法再补充一点：

当 C 样式数组传递给函数时，您应该显式指定数组start，并在使用 std::accumulate 时end（一个结束）地址。

例：

#include <numeric>
void outsideFun(int arr[], int n) {
    int sz = sizeof arr / sizeof arr[0]; // 1=decays to a ptr to the 1st element of the arr
    // int sum = accumulate(begin(arr), end(arr), 0); // Error:begin/end wouldn't work here
    int sum = accumulate(arr, arr + n, 0);            // 15 (Method 2 Only works!)
    std::cout << sum;
}
int main() {    
    int arr[] = { 1,2,3,4,5 };
    int sz = sizeof arr / sizeof arr[0];           // 5
    int sum = accumulate(begin(arr), end(arr), 0); // 15 (Method 1 - works)
    int cum = accumulate(arr, arr + sz, 0);        // 15 (Method 2 - works)
    outsideFun(arr, sz);
}