Question

我正在处理我的第一个代码，我在一个新问题上再次被阻止。

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

“变量 double SUM = 0 和变量 int count 。

获取向量的前值，将其添加到 SUM “

然后删除矢量

中的前值

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

SUM等于 SUM - u

每次 SUM＆gt;时，另一个向量 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);
}

Answer 1

让我们通过取出所有特定领域的东西来简化这一点，并讨论基本问题：

[我如何]将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是如何行动的，或者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());
}

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

微观优化是万恶之源。

在构建软件时，最好的方法是首先选择具有所需效率的正确算法（无论是空间还是时间效率），并以稳健，易于维护的方式构建。然后在发布版本中对您的程序进行概要分析，识别问题热点，并在必要时对代码的这些部分进行微观优化。如果您选择正确的算法并将其写好，您通常会发现不需要进行微观优化。

迭代：变量和向量前沿的总和，在另一个向量中导出，擦除向量前沿

1 个答案: