简化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) { 
    ... 
}