解析浮点数的 C 字符串
Parse a C-string of floating numbers
我有一个 C 字符串，其中包含一个由逗号和空格分隔的浮点数列表。每对数字由一个（或多个）空格分隔，表示一个点，其中 x 和 y 字段由逗号分隔（也可以由空格分隔）。
" 10,9 2.5, 3 4 ,150.32 "
我需要解析这个字符串以填充 Point(x, y).
的列表
以下是我当前的实现：
const char* strPoints = getString();
std::istringstream sstream(strPoints);
float x, y;
char comma;
while (sstream >> x >> comma >> y)
{
myList.push(Point(x, y));
}
因为我需要解析很多（最多 500,000 个）这些字符串，所以我想知道是否有 更快 的解决方案。
你可以先尝试关闭与C的同步I/O:
std::ios::sync_with_stdio(false);
来源：Using scanf() in C++ programs is faster than using cin?
你也可以尝试使用alternatives to iostream:
- boost_lexical_cast 并定义 BOOST_LEXICAL_CAST_ASSUME_C_LOCALE
- scanf
我认为您应该尝试 sync_with_stdio(false)。其他替代方案需要更多编码，我不确定您会赢得多少（如果有的话）。
我在使用 std::find 和 std::strtof 的组合解析点时获得了更好的性能，代码也没有复杂多少。这是我的测试 运行:
#include <iostream>
#include <sstream>
#include <random>
#include <chrono>
#include <cctype>
#include <algorithm>
#include <cstdlib>
#include <forward_list>
struct Point { float x; float y; };
using PointList = std::forward_list<Point>;
using Clock = std::chrono::steady_clock;
using std::chrono::milliseconds;
std::string generate_points(int n) {
static auto random_generator = std::mt19937{std::random_device{}()};
std::ostringstream oss;
std::uniform_real_distribution<float> distribution(-1, 1);
for (int i=0; i<n; ++i) {
oss << distribution(random_generator) << " ," << distribution(random_generator) << "\t \n";
}
return oss.str();
}
PointList parse_points1(const char* s) {
std::istringstream iss(s);
PointList points;
float x, y;
char comma;
while (iss >> x >> comma >> y)
points.push_front(Point{x, y});
return points;
}
inline
std::tuple<Point, const char*> parse_point2(const char* x_first, const char* last) {
auto is_whitespace = [](char c) { return std::isspace(c); };
auto x_last = std::find(x_first, last, ',');
auto y_first = std::find_if_not(std::next(x_last), last, is_whitespace);
auto y_last = std::find_if(y_first, last, is_whitespace);
auto x = std::strtof(x_first, (char**)&x_last);
auto y = std::strtof(y_first, (char**)&y_last);
auto next_x_first = std::find_if_not(y_last, last, is_whitespace);
return std::make_tuple(Point{x, y}, next_x_first);
}
PointList parse_points2(const char* i, const char* last) {
PointList points;
Point point;
while (i != last) {
std::tie(point, i) = parse_point2(i, last);
points.push_front(point);
}
return points;
}
int main() {
auto s = generate_points(500000);
auto time0 = Clock::now();
auto points1 = parse_points1(s.c_str());
auto time1 = Clock::now();
auto points2 = parse_points2(s.data(), s.data() + s.size());
auto time2 = Clock::now();
std::cout << "using stringstream: "
<< std::chrono::duration_cast<milliseconds>(time1 - time0).count() << '\n';
std::cout << "using strtof: "
<< std::chrono::duration_cast<milliseconds>(time2 - time1).count() << '\n';
return 0;
}
输出：
using stringstream: 1262
using strtof: 120
看Boost Spirit：
- How to parse space-separated floats in C++ quickly?
支持NaN，正负无穷就好了。也可以让你简洁地表达约束语法。
代码的简单改编
这是为您的语法改编的示例：
struct Point { float x,y; };
typedef std::vector<Point> data_t;
// And later:
bool ok = phrase_parse(f,l,*(double_ > ',' > double_), space, data);
迭代器可以是任意个迭代器。所以你可以把它和你的 C 字符串连接起来。
这是链接基准案例的直接改编。这向您展示了如何直接从内存映射文件中解析任何 std::istream 或 。
进一步优化（严格针对 C 字符串）
这是一个不需要事先知道字符串长度的版本（这很简洁，因为它避免了 strlen 调用，以防您没有可用的长度）：
template <typename OI>
static inline void parse_points(OI out, char const* it, char const* last = std::numeric_limits<char const*>::max()) {
namespace qi = boost::spirit::qi;
namespace phx = boost::phoenix;
bool ok = qi::phrase_parse(it, last,
*(qi::double_ >> ',' >> qi::double_) [ *phx::ref(out) = phx::construct<Point>(qi::_1, qi::_2) ],
qi::space);
if (!ok || !(it == last || *it == '[=11=]')) {
throw it; // TODO proper error reporting?
}
}
请注意我是如何使用 输出迭代器 的，以便您决定如何累积结果。 /just/ 解析为向量的明显包装器是：
static inline data_t parse_points(char const* szInput) {
data_t pts;
parse_points(back_inserter(pts), szInput);
return pts;
}
但您也可以做不同的事情（比如追加到现有容器，可以预先保留已知容量等）。像这样的事情通常最终会实现真正优化的集成。
这是在 ~30 行基本代码中完全演示的代码：
超棒的奖金
为了展示这个解析器的灵活性；如果您只想检查输入并获得点数，则可以将输出迭代器替换为一个简单的 lambda 函数，该函数递增计数器而不是添加新构造的点。
int main() {
int count = 0;
parse_points( " 10,9 2.5, 3 4 ,150.32 ", boost::make_function_output_iterator([&](Point const&){count++;}));
std::cout << "elements in sample: " << count << "\n";
}
由于所有内容都是内联编译器 will notice that the whole Point doesn't need to be constructed here and eliminate that code: http://paste.ubuntu.com/9781055/
The main function is seen directly invoking the very parser primitives. Handcoding the parser won't get you better tuning here, at least not without a lot of effort.
我有一个 C 字符串，其中包含一个由逗号和空格分隔的浮点数列表。每对数字由一个（或多个）空格分隔，表示一个点，其中 x 和 y 字段由逗号分隔（也可以由空格分隔）。
" 10,9 2.5, 3 4 ,150.32 "
我需要解析这个字符串以填充 Point(x, y).
的列表
以下是我当前的实现：
const char* strPoints = getString();
std::istringstream sstream(strPoints);
float x, y;
char comma;
while (sstream >> x >> comma >> y)
{
myList.push(Point(x, y));
}
因为我需要解析很多（最多 500,000 个）这些字符串，所以我想知道是否有 更快 的解决方案。
你可以先尝试关闭与C的同步I/O:
std::ios::sync_with_stdio(false);
来源：Using scanf() in C++ programs is faster than using cin?
你也可以尝试使用alternatives to iostream:
- boost_lexical_cast 并定义 BOOST_LEXICAL_CAST_ASSUME_C_LOCALE
- scanf
我认为您应该尝试 sync_with_stdio(false)。其他替代方案需要更多编码，我不确定您会赢得多少（如果有的话）。
我在使用 std::find 和 std::strtof 的组合解析点时获得了更好的性能，代码也没有复杂多少。这是我的测试 运行:
#include <iostream>
#include <sstream>
#include <random>
#include <chrono>
#include <cctype>
#include <algorithm>
#include <cstdlib>
#include <forward_list>
struct Point { float x; float y; };
using PointList = std::forward_list<Point>;
using Clock = std::chrono::steady_clock;
using std::chrono::milliseconds;
std::string generate_points(int n) {
static auto random_generator = std::mt19937{std::random_device{}()};
std::ostringstream oss;
std::uniform_real_distribution<float> distribution(-1, 1);
for (int i=0; i<n; ++i) {
oss << distribution(random_generator) << " ," << distribution(random_generator) << "\t \n";
}
return oss.str();
}
PointList parse_points1(const char* s) {
std::istringstream iss(s);
PointList points;
float x, y;
char comma;
while (iss >> x >> comma >> y)
points.push_front(Point{x, y});
return points;
}
inline
std::tuple<Point, const char*> parse_point2(const char* x_first, const char* last) {
auto is_whitespace = [](char c) { return std::isspace(c); };
auto x_last = std::find(x_first, last, ',');
auto y_first = std::find_if_not(std::next(x_last), last, is_whitespace);
auto y_last = std::find_if(y_first, last, is_whitespace);
auto x = std::strtof(x_first, (char**)&x_last);
auto y = std::strtof(y_first, (char**)&y_last);
auto next_x_first = std::find_if_not(y_last, last, is_whitespace);
return std::make_tuple(Point{x, y}, next_x_first);
}
PointList parse_points2(const char* i, const char* last) {
PointList points;
Point point;
while (i != last) {
std::tie(point, i) = parse_point2(i, last);
points.push_front(point);
}
return points;
}
int main() {
auto s = generate_points(500000);
auto time0 = Clock::now();
auto points1 = parse_points1(s.c_str());
auto time1 = Clock::now();
auto points2 = parse_points2(s.data(), s.data() + s.size());
auto time2 = Clock::now();
std::cout << "using stringstream: "
<< std::chrono::duration_cast<milliseconds>(time1 - time0).count() << '\n';
std::cout << "using strtof: "
<< std::chrono::duration_cast<milliseconds>(time2 - time1).count() << '\n';
return 0;
}
输出：
using stringstream: 1262
using strtof: 120
看Boost Spirit：
- How to parse space-separated floats in C++ quickly?
支持NaN，正负无穷就好了。也可以让你简洁地表达约束语法。
代码的简单改编
这是为您的语法改编的示例：
struct Point { float x,y; }; typedef std::vector<Point> data_t; // And later: bool ok = phrase_parse(f,l,*(double_ > ',' > double_), space, data);迭代器可以是任意个迭代器。所以你可以把它和你的 C 字符串连接起来。
这是链接基准案例的直接改编。这向您展示了如何直接从内存映射文件中解析任何
std::istream或 。进一步优化（严格针对 C 字符串）
这是一个不需要事先知道字符串长度的版本（这很简洁，因为它避免了
strlen调用，以防您没有可用的长度）：template <typename OI> static inline void parse_points(OI out, char const* it, char const* last = std::numeric_limits<char const*>::max()) { namespace qi = boost::spirit::qi; namespace phx = boost::phoenix; bool ok = qi::phrase_parse(it, last, *(qi::double_ >> ',' >> qi::double_) [ *phx::ref(out) = phx::construct<Point>(qi::_1, qi::_2) ], qi::space); if (!ok || !(it == last || *it == '[=11=]')) { throw it; // TODO proper error reporting? } }请注意我是如何使用 输出迭代器 的，以便您决定如何累积结果。 /just/ 解析为向量的明显包装器是：
static inline data_t parse_points(char const* szInput) { data_t pts; parse_points(back_inserter(pts), szInput); return pts; }但您也可以做不同的事情（比如追加到现有容器，可以预先保留已知容量等）。像这样的事情通常最终会实现真正优化的集成。
这是在 ~30 行基本代码中完全演示的代码：
超棒的奖金
为了展示这个解析器的灵活性；如果您只想检查输入并获得点数，则可以将输出迭代器替换为一个简单的 lambda 函数，该函数递增计数器而不是添加新构造的点。
int main() { int count = 0; parse_points( " 10,9 2.5, 3 4 ,150.32 ", boost::make_function_output_iterator([&](Point const&){count++;})); std::cout << "elements in sample: " << count << "\n"; }由于所有内容都是内联编译器 will notice that the whole
Pointdoesn't need to be constructed here and eliminate that code: http://paste.ubuntu.com/9781055/The main function is seen directly invoking the very parser primitives. Handcoding the parser won't get you better tuning here, at least not without a lot of effort.