C++ 迭代：变量和向量前沿之和，导出到另一个向量，擦除向量前沿

我正在处理我的第一个代码，我又被一个新问题阻塞了

我在向量中有一组值，我想在循环（伪代码）时执行以下：

“使一个变量加倍总和=0和一个变量int计数

取向量的前值，将其添加到总和”

然后清除向量中的前值

变量SUM应充当电容器：当SUM优于给定常数u时

SUM变为等于SUM-u

另一个向量vectorB每次SUM>u将存储count的值

现在我只有一个包含我所有值的向量，并将列表导出到一个.txt文件中

我想找到一种方法，将vectorA的前值放入局部变量中，将其添加到SUM中，然后删除这个前值。 可能吗？有更好的方法吗

代码如下：

#include <iostream>
#include <fstream>
#include <vector>
#include <iterator>
#include <cstdlib>
#include <string>
#include <sstream>
using namespace std;

// constant values

float Da=0.1; //densities
float Db=0.5;
float Dc=1;
double Dd=0.333333;

int l = 10;  //width & height
int h = 10;

float u = 10;  // UNIT

int main ()
{
    // vectors
    vector <double> VectorA;
    vector <double> vectorB;
    int I = 0;              //itération pour la somme des valeurs du vecteur
    double SUM = 0;         //somme des éléments du vecteurA

    float a = 0;
    float b = 0; // Local variables

    while (a<l+1, b<h+1){
        //values for given a & b

        double DL = Da-Da*(b/h)+Dc*(b/h);
        double DR = Db-Db*(b/h)+Dd*(b/h);
        double D  = DL-DL*(a/l)+DR*(a/l);

        //print
        //cout<<D<<endl;

        //store
        VectorA.push_back (D);

        // next pixel/unit & next line
        a = a+u;

        if (a>l) {
            a = 0;
            b = b+u;
        }
    }

    // export values to .txt file
    ofstream output_file("./step1.txt");
    ostream_iterator<double> output_iterator(output_file, "\n");
    copy(VectorA.begin(), VectorA.end(), output_iterator);
}

#包括
#包括
#包括
#包括
#包括
#包括
#包括
使用名称空间std；
//定值
浮动Da=0.1//密度
浮动Db=0.5；
浮点数Dc=1；
双Dd=0.333333；
int l=10//宽度和高度
int h=10；
浮点数u=10；//单位
int main（）
{
//载体
向量向量；
向量向量b；
int I=0；//这是一个很好的选择
double SUM=0；//somme deséléments du vecteurA
浮点数a=0；
浮点b=0；//局部变量
而（a让我们把所有特定领域的东西都去掉，让这变得简单一点，然后讨论一下基本问题：

[如何]将vectorA的前值放入要添加的局部变量中
将其相加，然后删除此前值

以下是一个简单的方法：

vector <double> vectorA;
double SUM = 0.0;
// ...

while (!vectorA.empty())
{
  const double curVal = vectorA.front();  // this strictly isn't necesarry.  the compiler might optimize this away
  SUM += curVal;
  vectorA.erase (vectorA.begin());
}

我真的不确定
count
是如何工作的，或者
vectorB
中存储了哪些值，但作为一个粗略的猜测，我将假设
count
每次
curVal>SUM
都会递增，并且
count
的结果新值被插入
vectorB
。因此，让我们尝试实现这一点地址：

vector <double> vectorA;
double SUM = 0.0;
const double u = /* ??? */;
int count = 0;
vector <int> vectorB;

// ...

while (!vectorA.empty())
{
  const int curVal = vectorA.front();  // this strictly isn't necesarry.  the compiler might optimize this away
  if (curVal > SUM)
  {
    SUM = curVal - u;
  ++count;
  vectorB.push_back (count);
  }

  vectorA.erase (vectorA.begin());
}

vectorA；
双和=0.0；
常数双u=/*？*/；
整数计数=0；
向量向量b；
// ...
而（！vectorA.empty（））
{
const int curVal=vectorA.front（）；//严格来说这不是必需的。编译器可能会对此进行优化
如果（曲线>总和）
{
SUM=曲线-u；
++计数；
向量b.推回（计数）；
}
vectorA.erase（vectorA.begin（））；
}

上面提到了微优化的机会，但回想一下Knuth的黄金法则：

微观优化是万恶之源

在构建软件时，最好的方法是首先选择正确的算法，并考虑所需的效率（无论是空间效率还是时间效率）并以一种健壮、易于维护的方式构建。然后在发布版本中分析您的程序，确定问题热点，并仅在必要时对代码的这些部分进行微优化。如果您选择正确的算法并编写良好，您通常会发现不需要微优化。
对不起，myInts是什么，myVals和curVal？对此很抱歉。
myInts
本来应该是你的
vectorA
，然后我把它改成了
myVals
，但是错过了一些。我会把它们全部改成
vectorA
@adrienlucca.wordpress.com：我希望现在有点意义。如何
count
运行良好…
count
是一个问题
int
当SUM>u时，它在网格上“舍入”位置，
count
的功能是在宽度
l
的每一行上标记这些时刻，谢谢，但是我现在不知道发生了什么，我只得到
1
作为向量b的输出
vector <double> vectorA;
double SUM = 0.0;
const double u = /* ??? */;
int count = 0;
vector <int> vectorB;

// ...

while (!vectorA.empty())
{
  const int curVal = vectorA.front();  // this strictly isn't necesarry.  the compiler might optimize this away
  if (curVal > SUM)
  {
    SUM = curVal - u;
  ++count;
  vectorB.push_back (count);
  }

  vectorA.erase (vectorA.begin());
}