3

boost::algorithm::join提供了一个方便的连接std::vector<std::string>。

std::vector<std::tuple<std::string,bool>>如果为真，在进行联接之前，您将如何扩展此功能以使用单引号（用于字符串）包围结果。

这对循环来说并不难，但我正在寻找一种能够充分利用标准算法和 C++11 特性（例如 lambdas）的解决方案。

如果可行，继续使用 boost 的 join： 优雅/可读性/简洁性更重要。

代码

#include <string>
#include <vector>
#include <tuple>
#include <boost/algorithm/string/join.hpp> 

int main( int argc, char* argv[] )
{
  std::vector<std::string> fields = { "foo", "bar", "baz" };
  auto simple_case = boost::algorithm::join( fields, "|" );

  // TODO join surrounded by single-quotes if std::get<1>()==true
  std::vector<std::tuple< std::string, bool >> tuples =
   { { "42", false }, { "foo", true }, { "3.14159", false } };

  // 42|'foo'|3.14159 is our goal
}

编辑

好的，我在下面接受了 kassak 的建议并查看了boost::transform_iterator()- 我被 boost 自己的文档中示例的冗长所推迟，所以我尝试std::transform()了 - 它没有我想要的那么短，但它似乎有效。

回答

#include <string>
#include <vector>
#include <tuple>
#include <iostream>
#include <algorithm>
#include <boost/algorithm/string/join.hpp> 

static std::string
quoted_join( 
    const std::vector<std::tuple< std::string, bool >>& tuples, 
    const std::string& join
)
{
    std::vector< std::string >  quoted;
    quoted.resize( tuples.size() );
    std::transform( tuples.begin(), tuples.end(), quoted.begin(),
        []( std::tuple< std::string, bool > const& t ) 
        {
            return std::get<1>( t ) ? 
                "'" + std::get<0>(t) + "'" :
                std::get<0>(t);
        }
    );
  return boost::algorithm::join( quoted, join );
}

int main( int argc, char* argv[] )
{
  std::vector<std::tuple< std::string, bool >> tuples =
  { 
    std::make_tuple( "42", false ), 
    std::make_tuple( "foo", true ), 
    std::make_tuple( "3.14159", false ) 
  };

  std::cerr << quoted_join( tuples, "|" ) << std::endl;
}
4

4 回答 4

3

先写make_transform_range( old_range, functor )。对于第一个版本，假设old_range是 a std::pairof 迭代器，但理想情况下它应该是任何承认begin(c).

然后答案变得非常干净和高效。获取您正在处理的范围，在不实际调用函数的情况下对其进行转换，然后对其调用 join 。

在我的手机上，所以输入相当多毛make_transform_range的东西超出了我的范围。而且它很毛茸茸。

这是一个不太抽象的尝试。

auto functor = []( my_pair const&p )->std::string {
  if (p.second) return quote( p.first );
  return p.first;
};
auto tbegin = boost::make_transform_iterator( b, functor );
auto tend = boost::make_transform_iterator( e, functor );
join(…);

...如果可行的话，它没有我担心的那么讨厌。我仍然认为这make_transform_range是值得的，但也许不是一次。

另一种方法是使用所有时髦语法的 boost range 库。它已经具有基于范围的变换。

于 2012-12-22T12:50:41.167 回答
3

It's easiest to use Boost.Range's transformed adaptor:

#include <string>
#include <vector>
#include <tuple>
#include <iostream>
#include <algorithm>
#include <boost/algorithm/string/join.hpp> 
#include <boost/range/adaptor/transformed.hpp>

int main()
{
    std::vector<std::tuple< std::string, bool >> tuples =
    { 
        std::make_tuple( "42", false ), 
        std::make_tuple( "foo", true ), 
        std::make_tuple( "3.14159", false ) 
    };

  std::cout
      << boost::algorithm::join( 
                tuples | boost::adaptors::transformed(
                    [](std::tuple< std::string, bool > const &tup){
                        return std::get<1>(tup) ? 
                            "'" + std::get<0>(tup) + "'" :
                                  std::get<0>(tup);
                    }
                ), "|" )
      << std::endl;
}
于 2012-12-26T03:30:34.363 回答
1

如果您想使用连接，您可以将集合包装起来boost::transform_iterator并在需要时添加引号

于 2012-12-22T08:23:54.303 回答
0

Your requirement is not a generic one for that why not just loop through the vector and append the strings ?

std::vector<std::tuple<std::string, bool>> coll;
coll.push_back(make_tuple("foo", false));
coll.push_back(make_tuple("bar", true));
coll.push_back(make_tuple("foo", false));
std::string result;
result.reserve(coll.size());

for(auto& val : coll)
{
  result += std::get<1>(val) ? ("'" + std::get<0>(val) + "'|") 
                             : std::get<0>(val) + "|";
}

boost::trim_if(result, boost::is_any_of("|"));
std::cout << result << "\n";
于 2012-12-26T13:12:43.347 回答