迭代：變量和矢量前沿的總和，在另一個矢量中導出，擦除矢量前端

Question

我正在處理我的第一個代碼，並且在新問題上再次被阻塞。

我有一個vectorA一堆值，並且我想執行以下而循環（在僞代碼）：

「製作可變雙SUM = 0和可變INT計數。

採取矢量的前值，將其添加到SUM「

然後，在矢量擦除前值

可變SUM應該作爲電容器起作用：當SUM優於給定的恆定ü，

SUM變得等於到SUM - u

另一個矢量vecto rB中將存儲的每一次計值SUM>ü

現在我只是有一個包含我所有的值和列表導出到一個.txt文件一個VectorA。

我想找到一種方法來將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的黃金法則：

微優化是一切罪惡的根源。

在構建軟件，最好的辦法是先選擇正確的算法，考慮到所需的效率（無論是時間或空間效率），並建立在一個強大的，易於maintaned方式。然後在發佈版本中對程序進行概要分析，確定問題熱點，並僅在需要的地方對代碼的這些部分進行微優化。如果你選擇正確的算法開始，並寫得很好，你會發現不需要微型優化。