2

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

我在vectorA中有一堆值，我想执行以下while循环（在伪代码中）：

“创建一个变量double SUM = 0和一个变量int count。

取向量的前值，加到SUM "

然后擦除向量中的前值

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

SUM 等于SUM - u

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

现在我只有一个包含我所有值的 VectorA 并将列表导出到 .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);
}
4

1 回答 1

3

让我们去掉所有特定领域的东西，让这更简单一些，只讨论基本问题：

【如何】将vectorA的前值放入一个局部变量中添加到SUM中，然后擦除这个前值？

这是一个简单的方法：

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

现在让我们合并u：

vector <double> vectorA;
double SUM = 0.0;
const double u = /* ??? */;

// ...

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

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

我不太确定如何count操作，或者将哪些值存储在 to 中vectorB，但作为一个疯狂的猜测，我会假设count每次都会递增curVal > SUM，并且生成的新值 forcount被插入 to 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());
}

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

微优化是万恶之源。

在构建软件时，最好的方法是首先选择正确的算法并考虑到所需的效率（无论是空间效率还是时间效率），然后以一种健壮、易于维护的方式构建它。然后在发布版本中分析您的程序，识别问题热点，并仅在必要时对代码的那些部分进行微优化。如果你选择正确的算法开始，并且写得好，你会经常发现不需要微优化。

于 2013-07-10T13:10:15.993 回答