Question

我有一个读取文件并输出平均测试分数的作业。

这很简单，但我不喜欢平均值是如何完成的。

average = (test1 + test2 + test3 + test4 + test5) / 5.0;

有没有办法让它除以考试成绩的数量？我在书中或谷歌找不到这样的东西。像

这样的东西

average = (test + test + test + test) / ntests;

Answer 1

如果你有矢量或数组中的值，只需使用<numeric>中的std::accumulate：

std::vector<double> vec;
// ... fill vec with values (do not use 0; use 0.0)
double average = std::accumulate(vec.begin(), vec.end(), 0.0) / vec.size();

Answer 2

步骤1.通过迭代（如果你想完成）或递归（如果你想要勇敢）将所有测试分数放入一个数组（如果你想要简单和速度）或链表（如果你想要灵活性）但很慢）

步骤2.遍历数组/列表直到结束;随时添加每个单元/节点的内容。保持对你当前所在的细胞/节点的计数。

步骤3.从第一个变量中取出总和，并将其除以跟踪您所在位置的第二个变量。这将产生平均值。

Answer 3

这是我通过指定lambda函数获取每个值然后加起来获取容器元素平均值的概括：

template <typename ForwardIterator, typename F>
double inline averageOf (ForwardIterator first, ForwardIterator last, F function) {
    std::vector<typename std::result_of<F(typename ForwardIterator::value_type)>::type> values;
    while (first != last) {
        values.emplace_back (function(*first));
        ++first;
    }
    return static_cast<double>(std::accumulate (values.begin(), values.end(), 0)) / values.size();
}

我测试过的客户端代码就像

const std::list<CharmedObserver*> devotees =
    charmer->getState<CharmerStateBase>(CHARMER)->getDevotees();
const int averageHitPointsOfDevotees = averageOf (devotees.begin(), devotees.end(),
    [](const CharmedObserver* x)->int {return x->getCharmedBeing()->getHitPoints();});

Answer 4

C ++ 11提供了很好的解决方案：

constexpr auto countArguments() -> size_t
{
    return 0;
}

template<class T1, class ... Ti>
constexpr auto countArguments(T1, Ti ...xi) -> size_t
{
    return 1 + countArguments(xi...);
}

template<class T>
constexpr auto sumAruguments(T x) -> double
{
    return x;
}

template<class T1, class ... Ti>
constexpr auto sumAruguments(T1 x1, Ti ...xi) -> double // decltype(x1 + sumAruguments(xi...))
{
    return x1 + sumAruguments(xi...);
}

template<class...T>
constexpr auto avarage(T...xi) -> double
{
    return sumAruguments(xi...) / countArguments(xi...);
}

我无法写它，因此它会自动推断返回类型。当我尝试时，我得到average(-2)的奇怪结果。

https://wandbox.org/permlink/brssPjggn64lBGVq

Answer 5

您还可以使用可变数量的参数计算平均值。这个函数的原理是将未知数量的参数存储在堆栈中，我们可以使用它们。

double average(int n, ...)          // where n - count of argument (number)
{  
    int *p = &n;                   // get pointer on list of number in stack
    p++;                           // get first number
    double *pp = (double *)p;      // transformation of the pointer type
    double sum = 0; 
    for ( int i = 0; i < n; pp++, i++ ) //looking all stack
       sum+=(*pp);                 // summarize
    return sum/n;              //return average
}

您可以使用以下功能：

double av1 = average( 5, 3.0, 1.5, 5.0, 1.0, 2.0 );
double av2 = average( 2, 3.0, 1.5 );

但是参数的数量必须与n匹配。

Answer 6

想知道，为什么没有人提到boost::accumulators。它不是已经发布的解决方案中最短的，但可以更容易地扩展到更一般的统计值。像标准偏差或更高的时刻。

#include <iostream>
#include <boost/accumulators/accumulators.hpp>
#include <boost/accumulators/statistics/stats.hpp>
#include <boost/accumulators/statistics/mean.hpp>
#include <algorithm>
#include <vector>

double mean(const std::vector<double>& values) {
    namespace bo = boost::accumulators;

    if (values.empty()) return 0.;
    bo::accumulator_set<double, bo::stats<bo::tag::mean>> acc;
    acc=std::for_each(values.begin(), values.end(), acc);
    return bo::mean(acc);
}

int main()
{
    std::vector<double> test = { 2.,6.,4.,7. };
    std::cout << "Mean:   " << mean(test) << std::endl;
    std::cout << "Mean:   " << mean({}) << std::endl;

    return 0;
}

如何在C ++中获得平均值？

6 个答案: