簡化FOR循環

Question

我有一個函數，它基本上從雙精度值中讀取值，將它們附加到一個字符串中（同時確保每個字符之間的空格並設置它們的精度），並返回最終結果，減去最終的空格：

std::string MultiplePrintProperties::GetHpitchString() 
{  
    std::string str; 
    vector<double>::iterator it;  

    for (it = Vals.begin();  
      it != Vals.end(); 
      it++) 
    { 
     ostringstream s;  

     // Set precision to 3 digits after the decimal point 
     // and read into the string 
     boost::format fmt("%.3f "); 
     s << fmt % *(it); 
     str.append(s.str());  
    } 

    // Remove last white space and return string 
    return str.substr(0, str.length() - 1); 
} 

我想知道這段代碼是否可以以任何方式簡化。我最近一直在調查for_each和functor的用法，但還沒有弄清楚這些技術如何改進這個特定的例子。

Answer 1

因爲你實際上轉化成雙打字符串，並追加這些字符串的字符串流，你可以使用std::transform爲：

// your functor, transforming a double into a string 
struct transform_one_double { 
    std::string operator()(const double& d) const { 
    boost::format fmt("%.3f "); 
    return (fmt % d).str(); 
    } 
}; 

// iteration code, taking each value and inserting the transformed 
// value into the stringstream. 
std::transform(vals.begin(), vals.end() 
       , std::ostream_iterator<std::string>(s, " ") 
       , transform_one_double()); 

Answer 2

您可以創建一個類重載operator()具有參考到std :: string作爲成員。您將聲明此類的一個對象並將該字符串傳遞給構造函數，然後使用該對象作爲for_each的第三個參數。將爲每個元素調用重載的operator（），並將文本附加到引用的字符串。

Answer 3

這些天好像我有點老毛骨悚然。我會做這樣的：

std::string MultiplePrintProperties::GetHpitchString() 
{  
    std::string str; 
    vector<double>::iterator it;  

    for (it = Vals.begin();  
      it != Vals.end(); 
      it++) 
    { 
     // Set precision to 3 digits after the decimal point 
     // and write it into the string 
     char buf[20]; 
     snprintf(buf, 20, "%.3f", *it); 
     if (str.length() > 0) 
      str.append(" "); 
     str.append(buf);   
    } 

    return str; 
} 

Answer 4

如上所述，很多方法來實現這一目標，但是...... 沒有這種方法只是乞求有一些更多的參數和模板化正在？ 假設有

template< class tType > 
std::string PrintVectorToArray(const std::vector<tType>& V, const char* Seperator); 

則可以創建

1，2，3

1.0，然後2.0，然後5.0

任何類型可轉換爲字符串和任何分隔符！ 我曾經這樣做過，現在發現自己使用這種方法很多。

Answer 5

我會建議使用單個字符串流和單個格式。那些並不便宜。

std::string MultiplePrintProperties::GetHpitchString() 
{  
    std::ostringstream s;  
    // Set precision to 3 digits after the decimal point 
    static boost::format fmt("%.3f "); 

    for (vector<double>::iterator it = Vals.begin();  
      it != Vals.end(); it++) 
    { 
     // and read into the string 
     s << fmt % *(it); 
    } 
    // Remove last white space (if present) and return result 
    std::string ret = s.str(); 
    if (!ret.empty()) ret.resize(ret.size()-1); 
    return ret; 
} 

如果我分析信息，證明它仍然是一個瓶頸，我會考慮使用靜態ostringstream：

static std::ostringstream s;  
... 
std::string ret; 
std::swap(ret, s.str()); 
return ret; 

Answer 6

的「格式化」變量應你的循環之外聲明，如設置格式化每次迭代都很慢並且不需要。也不需要stringstream。所以身體會變成這樣的：

std::string s; 
    std::vector<double>::iterator i = vals.begin(); 

    if (i != vals.end()) 
{ 
    boost::format fmt("%.3f"); 
    s = str(fmt % *i++); 

    while (i != vals.end()) 
    s += ' ' + str(fmt % *i++); 
} 

Answer 7

我沒有找到你的原代碼臃腫或迫切需要簡化。不過，我想移動

boost::format fmt("%.3f"); 

和

ostringstream s; 

圈外，以確保他們只初始化一次。這樣可以節省很多str.append（）。我猜xtofl的std :: transform（）解決方案會產生這個問題（通過爲結構初始化一次就可以很容易地解決這個問題）。

如果您正在尋找其他替代

for (it = begin(); it != end(); ++it) {...} 

退房BOOST_FOREACH這將使您按以下方式進行迭代：

std::vector<double> list; 
BOOST_FOREACH(double value, list) { 
    ... 
}