C ++如何只求和存储在矢量中的偶数值？ 在C ++ 14和C ++ 17中在C ++ 20中

如何解决C ++如何只求和存储在矢量中的偶数值？ 在C ++ 14和C ++ 17中在C ++ 20中

我是C ++的新手，我完全不了解如何仅对C ++中向量中存储的偶数求和。

任务本身要求用户输入一定数量的随机整数，在输入为0时停止，然后返回偶数值的数量和这些偶数值的总和。

据我所知：

#include <algorithm>
#include <functional>
#include <iostream>
#include <vector>
#include <numeric>

using namespace std;

int main()

{
    vector<int> vet;
    int s = 1;
        while (s != 0) {
        std::cin >> s;
        vet.push_back(s);
    }


    int n = count_if(vet.begin(),vet.end(),[](int n) { return (n % 2) == 0; });
    cout << n << endl;
    

    //here is the start of my problems and lack of undertanding. Basically bad improv from previous method
    int m = accumulate(vet.begin(),[](int m) { for (auto m : vet) {
              return (m % 2) == 0; });
              cout << m << endl;          //would love to see the sum of even values here

        
        
   return 0;
}

解决方法

要传递给std::accumulate的函数采用两个值：当前累加值和当前元素的值。

您应该做的是将值添加为偶数，否则将不做任何更改。

int m = accumulate(vet.begin(),vet.end(),[](int cur,int m) {
            if ((m % 2) == 0) {
                return cur + m; // add this element
            } else {
                return cur; // make no change
            }
        });

,

从c ++ 20开始，您可以分离出检查偶数的逻辑和对这些值求和的逻辑：

auto is_even = [](int i) { return i % 2 == 0; };

auto evens = vet | std::views::filter(is_even);

auto sum = std::accumulate(std::begin(evens),std::end(evens),0);  

这里是demo。

,

这是我的解决方案（很抱歉，如果不对，我正在用手机写它）

您不需要向量形式，只需要从输入中直接检查数字是否可被2整除 我的解决方案：（有点丑陋）

#include <iostream>

using namespace std;

    int main()
    {
        int s {1};
        int sum{};
        int countNum{};
        while (s != 0)
        {
            cin >> s;
            if (s % 2 == 0)
            {
                sum += s;
                countNum++;
            }
        }
        cout << countNum << ' ' << sum;
    }

,

我真的不知道您要在代码的第二部分中做什么，但是您可以通过这种方式将偶数求和，并且当您使用命名空间std时，我想告诉您另一件事，您不需要写std :: cin您只能直接写cin

#include <iostream>
#include <vector>

using namespace std;

int main()

{
    vector<int> vet;
    int s = 1;
    //Take Input
    while (s != 0) {
        cin >> s;
        vet.push_back(s);
    }
    //count elements
    int elements_count = vet.size(); //vet.size() return the total number of elements of vector

    //store the sum here
    int sum=0;

    //loop on the vector and sum only even numbers
    for(int i=0;i<elements_count;i++){
        if(vet[i] %2 ==0)
            sum += vet[i];//check of the element of index i in the vector is even if it true it will add to sum
    }
    cout << sum;

   return 0;
}

,

int sumEven=0;
int v[100];
int n;//number of elements you want to enter in the array
do{cout<<"Enter n";
  cin>>n;}while(n<=0);
//in a normal 1 dimensional array
for(int i=0;i<n;i++)
if(v[i]%2==0)
    sumEven+=v[i];

//in a vector
vector<int> v;
for(vector<int>::iterator it=v.begin();it!=v.end();it++)
if(*it%2==0)
    sumEven+=v[i];

,

基于范围的循环

基于范围的for循环可以说永远是STL算法的有效替代方法，特别是在算法的运算符不重要的情况下。

在C ++ 14和C ++ 17中

例如在立即执行的可变lambda中包装基于范围的偶数累积for循环：

#include <iostream>
#include <vector>

int main() {
    // C++17: omit <int> and rely on CTAD.
    const std::vector<int> v{1,10,2,7,4,5,8,13,18,19};
    const auto sum_of_even_values = [sum = 0,&v]() mutable {
        for (auto val : v) { 
            if (val % 2 == 0) { sum += val; }
        }
        return sum;
    }();
    
    std::cout << sum_of_even_values; // 42
}

在C ++ 20中

从C ++ 20开始，您可以在基于范围的for循环和the ranges library中使用初始化语句，从而可以在基于范围的for循环的初始化语句中声明一个二进制比较器。 ，然后将其与std::ranges::filter_view适配器一起应用于循环的范围表达式：

#include <iostream>
#include <vector>
#include <ranges>

int main() {
    const std::vector v{1,19};

    const auto sum_of_even_values = [sum = 0,&v]() mutable {
        for (auto is_even = [](int i) { return i % 2 == 0; };
             auto val : v | std::ranges::views::filter(is_even)) { 
            sum += val;
        }
        return sum;
    }();
    
    std::cout << sum_of_even_values; // 42
}

,

类似于上面的答案，但是如果您也要保留偶数向量，则有两种方法。

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

int main() {

    std::vector<int> vec = {1,3,6,9,10};

    // Hold onto what we know is the right answer.
    int known_sum = 2+4+6+8+10;

    // Copy only even values into another vector
    std::vector<int> even_values;
    std::copy_if(vec.begin(),vec.end(),std::back_inserter(even_values),[](int val){ return val%2==0; });

    // Compute sum from even values vector
    int even_value_sum = std::accumulate(even_values.begin(),even_values.end(),0);

    // Compute sum from original vector
    int even_value_second = std::accumulate(vec.begin(),[](int current_sum,int new_value) {
            return new_value%2==0 ? current_sum + new_value:current_sum;
        }
    );

    // These should all be the same.
    std::cout << "Sum from only even vector: " << even_value_sum << std::endl;
    std::cout << "Sum from binary op in std accumulate: " << even_value_second << std::endl;
    std::cout << "Known Sum: " << known_sum << std::endl;

}