C++ 如何在C++；？

而不是打字

array[0] + array[1] //.....(and so on)

有没有办法把数组中的所有数字相加？我使用的语言是C++

---

我希望能够用更少的打字来完成这项工作，如果我只是把它全部打出来的话。

我能看到的最简单的方法是使用循环。其好处是，您可以在任何整数数组上使用它，而无需重写太多代码。我更经常使用Java，所以我希望不会有太多语法错误，但类似的东西应该可以工作：

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

int addArray（int[]数组，int长度）{
整数和=0；
对于（int count=0；count假设您有一个
int数组[N]

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

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

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

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

inta[]={1,3,5,7,9}；
int total=累加（开始（a）、结束（a）、0加（）；

注意，本例假设您在某个地方：

#include <numeric>
using namespace std;

#包括
使用名称空间std；

另请参见：和。
如果使用
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;
}

#包括//std:：cout
#include//std:：valarray
int main（）{
std:valarray-myvalarray（4）；
myvalarray[0]=0；
myvalarray[1]=10；
myvalarray[2]=20；
myvalarray[3]=30；
std：：cout试试这个：

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;

int数组[]={3,2,1,4}；
整数和=0；
对于（int i=0；i<4；i++）{
总和=总和+数组[i]；
}
std:：cout在C++17中，可以使用折叠表达式：

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

假设arr是
std:：array
。但由于它是可变的，因此需要借助助手进行一些推送：

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>>>{});
}

使用名称空间std；
模板
int sum\u impl（数组和a，索引\u序列）
{
返回和impl（get（forward（a））…）；
}
模板
整数和（数组和a）
{
返回金额（远期（a），
使_索引_序列{}）；
}

因此，假设这些助手已就位，代码将如下所示：

std::apply(sum_impl, arr);

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;
}

模板
整数和（Ts&&…a）
{
回报率（a+…）；
}
int main（）
{
数组arr{0,1,2,3,4,5,6,7,8,9}；
cout我们可以使用用户定义的函数

代码段：

#包括
使用名称空间std；
整数和（整数arr[]，整数n）
{
整数和=0；
对于（int i=0；i如果您的编译器支持c++17，您可以使用参数包和折叠表达式的组合来实现这一点。模板参数包是一个接受零个或多个模板参数的模板参数，在这种情况下，折叠通过二进制运算符减少参数包。（
+
）

#包括
#包括
#包括
/* 
*参考资料：
*   [1] https://en.cppreference.com/w/cpp/language/fold
*   [2] https://en.cppreference.com/w/cpp/language/parameter_pack
*/
模板
自动求和（T…args）
{
返回值（args+…）；
}
模板
自动求和（T，std:：index\u序列）
{
返回和（t[Is]…）；
}
int main（）
{
数组a1={1,4,3}；
int a2[5]={1,2,3,4,0}；
std:：cout
std:：acculate
只做它在tin上所说的，这是在循环中使用它的一个原因。对于向量：比acculate更干净，假设您有C++11支持，并且不需要两个额外的include。通过使用短变量名，这个golfs比acculate更好（即使不考虑include）。我想累积的唯一优点是自我记录？@Ciro:这不是累积的唯一优点。如果你有
int数组[100]；
并且你像这样对它的一部分排序
排序（a，a+n）；
，使用累积的解决方案可以让我创建一行漂亮的总和：
int revenue=acculate（a，a+min（m，n）（0）；。你可以在这里查找我在这里使用的代码：C++ C++ INT[]需要“int *数组”。否则，它工作得很好。你可以添加你正在使用循环的函数，这样将来他们可以调用AdAdRayAy（）。@Scooter，在这个上下文中这两个都相当于编译器。@chris仔细看看。他们是用Java的方式来做的——“int[]数组”-而不是“int array[]”。但是，是的，我应该使用“int array[]”，因为它比“int*array”更清晰@Scooter，啊，是的，我没有注意到。实际上，如果我必须为参数选择一个，我更喜欢
int*
我自己，因为它不会被另一个类型（如
int[]
是；你看到的就是你得到的，然后任何不知道转换的人都不会试图期望
sizeof
工作或任何事情。因为那个了不起的尼克，投票吧！；）值得注意的是，加法是默认值。另外值得注意的是，对于
int
以外的类型，第三个参数必须是正确类型的0，例如，当对
double
s求和时为0.0。我不知道为什么或何时更改，但我必须
#include
才能工作。确认这一点。@dasblinkenlight-如果我的数组是arra怎么办数据指针的y个，如-slist->items_per_level=（uint64_t*）malloc（sizeof（uint64_t）*maxLevel）；@gansub这是一个非常好的答案。你应该解释你的答案。他们有很多关于这个问题的答案，并且被标记为已接受。请解释这是做什么，而不仅仅是发布代码
int Sum;
for(int& S: List) Sum += S;

#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;
}