简化 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 和函子的使用，但无法弄清楚这些技术如何改进这个特定的示例。

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

看来我这些天有点老了。我会这样做：

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 3

'fmt' 变量应该在循环之外声明，因为每次迭代设置格式都很慢并且不需要。也不需要字符串流。那么身体就会变成这样：

  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 4

我没有发现您的原始代码臃肿或迫切需要简化。然而，我会将

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

Answer 5

您可以创建一个带有重载 operator() 的类，并将 std::string 引用作为成员。您将声明此类的一个对象并将字符串传递给构造函数，然后使用该对象作为 for_each 的第三个参数。将为每个元素调用重载的operator()，并将文本附加到引用的字符串中。

Answer 6

如上所述，有很多方法可以实现这一目标，但是......
这个方法不只是要求有更多的参数并被模板化吗？
假设你有

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

那么你可以创建

1 2 3

1,2,3

1.0，然后 2.0，然后 5.0

对于任何可转换为字符串的类型并使用任何分隔符！
我曾经这样做过，现在发现自己经常使用这种方法。

Answer 7

我建议使用单个字符串流和单个格式。这些并不便宜。

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;