#include <scn/scan.h>
#include <print> // for std::println (C++23)
int main() {
// Read two integers from stdin
// with an accompanying message
if (auto result =
scn::prompt<int, int>("What are your two favorite numbers? ", "{} {}")) {
auto [a, b] = result->values();
std::println("Oh, cool, {} and {}!", a, b);
} else {
std::println(stderr, "Error: {}", result.error().msg());
}
}
Try out in Compiler Explorer.
scnlib
is a modern C++ library for replacing scanf
and std::istream
.
This library attempts to move use ever so much closer to replacing iostream
s
and C stdio altogether.
It's faster than iostream
(see Benchmarks), and type-safe, unlike scanf
.
Think {fmt} or C++20 std::format
, but in the
other direction.
This library is the reference implementation of the ISO C++ standards proposal P1729 "Text Parsing".
The documentation can be found online, from https://scnlib.dev.
To build the docs yourself, build the scn_docs
target generated by CMake.
These targets are generated only if the variable SCN_DOCS
is set in CMake
(done automatically if scnlib is the root project).
The scn_docs
target requires Doxygen, Python 3.8 or better, and the pip3
package poxy
.
See more examples in the examples/
folder.
#include <scn/scan.h>
#include <print>
int main() {
// Reading a std::string will read until the first whitespace character
if (auto result = scn::scan<std::string>("Hello world!", "{}")) {
// Will output "Hello":
// Access the read value with result->value()
std::println("{}", result->value());
// Will output " world":
// result->range() returns a subrange containing the unused input
// C++23 is required for the std::string_view range constructor used below
std::println("{}", std::string_view{result->range()});
} else {
std::println("Couldn't parse a word: {}", result.error().msg());
}
}
#include <scn/scan.h>
int main() {
auto input = std::string{"123 456 foo"};
auto result = scn::scan<int, int>(input, "{} {}");
// result == true
// result->range(): " foo"
// All read values can be accessed through a tuple with result->values()
auto [a, b] = result->values();
// Read from the remaining input
// Could also use scn::ranges::subrange{result->begin(), result->end()} as input
auto result2 = scn::scan<std::string>(result->range(), "{}");
// result2 == true
// result2->range().empty() == true
// result2->value() == "foo"
}
#include <scn/scan.h>
#include <ranges>
int main() {
auto result = scn::scan<int>("123" | std::views::reverse, "{}");
// result == true
// result->begin() is an iterator into a reverse_view
// result->range() is empty
// result->value() == 321
}
#include <scn/scan.h>
#include <vector>
int main() {
std::vector<int> vec{};
auto input = scn::ranges::subrange{"123 456 789"sv};
while (auto result = scn::scan<int>(input), "{}")) {
vec.push_back(result->value());
input = result->range();
}
}
- Blazing fast parsing of values (see Benchmarks)
- Modern C++ interface, featuring
- type safety (variadic templates, types not determined by the format string)
- convenience (ranges)
- ergonomics (values returned from
scn::scan
, no output parameters)
"{python}"
-like format string syntax- Including compile-time format string checking
- Minimal code size increase (in user code, see Benchmarks)
- Usable without exceptions, RTTI, or
<iostream>
s- Configurable through build flags
- Limited functionality if enabled
- Supports, and requires Unicode (input is UTF-8, UTF-16, or UTF-32)
- Highly portable
- Tested on multiple platforms, see CI
- Works on multiple architectures, tested on x86, x86-64, arm, aarch64, riscv64, ppc64le, and riscv64
scnlib
uses CMake.
If your project already uses CMake, integration should be trivial, through
whatever means you like:
make install
+ find_package
, FetchContent
, git submodule
+ add_subdirectory
,
or something else.
There are community-maintained packages available on Conan and on vcpkg.
The scnlib
CMake target is scn::scn
# Target with which you'd like to use scnlib
add_executable(my_program ...)
target_link_libraries(my_program scn::scn)
See docs for usage without CMake.
A C++17 compatible compiler is required. The following compilers are tested in CI:
- GCC 7 and newer
- Clang 8 and newer
- Visual Studio 2019 and 2022
Including the following environments:
- 32-bit and 64-bit builds on Windows
- libc++ on Linux
- gcc on Alpine Linux
- AppleClang and gcc on macOS 12 (Monterey) and 14 (Sonoma)
- clang-cl with VS 2019 and 2022
- MinGW and MSys2
- GCC on armv6, armv7, aarch64, riscv64, s390x, and ppc64le
- Visual Studio 2022, cross compiling to arm64
All times below are in nanoseconds of CPU time. Lower is better.
Test | Test 1 "single" |
Test 2 "repeated" |
Test average |
---|---|---|---|
scn::scan |
23.8 | 30.4 | 27.1 |
scn::scan_value |
20.5 | 27.4 | 24.0 |
scn::scan_int |
16.5 | 24.1 | 20.3 |
scn::scan_int_exhaustive_valid |
4.08 | - | 4.08 |
std::stringstream |
117 | 53.9 | 85.5 |
sscanf |
71.3 | 474 | 272.7 |
strtol |
16.3 | 23.8 | 20.1 |
std::from_chars |
8.73 | 13.0 | 10.9 |
fast_float::from_chars |
6.87 | 11.8 | 9.35 |
Test | Test 1 "single" |
Test 2 "repeated" |
Test Average |
---|---|---|---|
scn::scan |
55.8 | 63.7 | 59.7 |
scn::scan_value |
52.1 | 58.8 | 55.5 |
std::stringstream |
294 | 271 | 283 |
sscanf |
159 | 704 | 432 |
strtod |
79.1 | 153 | 116 |
std::from_chars |
18.0 | 28.1 | 23.0 |
fast_float::from_chars |
20.6 | 27.8 | 24.2 |
Test | |
---|---|
scn::scan<string> |
24.5 |
scn::scan<string_view> |
22.2 |
scn::scan_value<string> |
23.1 |
scn::scan_value<string_view> |
21.0 |
std::stringstream |
134 |
sscanf |
58.4 |
scn::scan
is always faster than usingstringstream
s andsscanf
std::from_chars
/fast_float::from_chars
is faster thanscn::scan
, but it supports fewer featuresstrtod
is slower thanscn::scan
, and supports fewer featuresscn::scan_value
is slightly faster compared toscn::scan
scn::scan_int
is faster than bothscn::scan
andscn::scan_value
strtol
is ~on-par withscn::scan_int
.scn::scan_int_exhaustive_valid
is blazing-fast.
Above,
- "Test 1" refers to scanning a single value from a string,
which only contains the text representation for that value.
The time used for creating any state needed for the scanner is included,
for example, constructing a
stringstream
. This test is called"single"
in the benchmark sources. - "Test 2" refers to the average time of scanning a value,
which contains multiple values in their text representations, separated by
spaces. The time used for creating any state needed for the scanner
is not included. This test is called
"repeated"
in the benchmark sources. - The string test is an exception: strings are read one after another from a sample of Lorem Ipsum.
The difference between "Test 1" and "Test 2" is most pronounced when using
a stringstream
, which is relatively expensive to construct,
and seems to be adding around ~50ns of runtime.
With sscanf
, it seems like using the %n
specifier and skipping whitespace
are really expensive (~400ns of runtime).
With scn::scan
and std::from_chars
, there's really no state to construct,
and the results for "Test 1" and "Test 2" are thus quite similar.
These benchmarks were run on a Fedora 40 machine, running Linux kernel version
6.8.9, with an AMD Ryzen 7 5700X processor, and compiled with clang version 18.1.1,
with -O3 -DNDEBUG -march=haswell
and LTO enabled.
These benchmarks were run on 2024-05-23 (commit 3fd830de).
The source code for these benchmarks can be found in the benchmark
directory.
You can run these benchmarks yourself by enabling the CMake
variable SCN_BENCHMARKS
.
This variable is ON
by default, if scnlib
is the root CMake project,
and OFF
otherwise.
$ cd build
$ cmake -DSCN_BENCHMARKS=ON \
-DCMAKE_BUILD_TYPE=Release -DCMAKE_INTERPROCEDURAL_OPTIMIZATION=ON \
-DSCN_USE_HASWELL_ARCH=ON ..
$ cmake --build .
# choose benchamrks to run in ./benchmark/runtime/*/*_bench
$ ./benchmark/runtime/integer/scn_int_bench
All sizes below are in kibibytes (KiB), measuring the compiled executable.
"Stripped size" shows the size of the executable after running strip
.
Lower is better.
Size of scnlib
shared library (.so
): 1.7M
Method | Executable size | Stripped size |
---|---|---|
empty | 7.6 | 4.4 |
std::scanf |
10.4 | 5.8 |
std::istream |
11.1 | 6.2 |
scn::input |
11.2 | 6.4 |
Size of scnlib
shared library (.so
): 1.1M
Method | Executable size | Stripped size |
---|---|---|
empty | 7.5 | 4.4 |
std::scanf |
10.3 | 5.8 |
std::istream |
11.0 | 6.1 |
scn::input |
12.4 | 6.6 |
Size of scnlib
shared library (.so
): 20M
Method | Executable size | Stripped size |
---|---|---|
empty | 18.4 | 5.2 |
std::scanf |
429 | 11.8 |
std::istream |
438 | 9.4 |
scn::input |
2234 | 51.3 |
When using optimized builds, depending on compiler flags, scnlib provides a
binary, the size of which is within ~5% of what would be produced with scanf
or <iostream>
s.
In a Debug-environment, scnlib is ~5x bigger when compared to scanf
or <iostream>
. After strip
ing the binaries,
these differences largely go away, except in Debug builds.
In these tests, 25 translation units are generated, in all of which values are
read from stdin
five times.
This is done to simulate a small project.
scnlib
is linked dynamically, to level the playing field with the standard
library, which is also dynamically linked.
The code was compiled on Fedora 40, with gcc 14.1.1.
See the directory benchmark/binarysize
for the source code.
You can run these benchmarks yourself by enabling the CMake
variable SCN_BENCHMARKS_BINARYSIZE
.
This variable is ON
by default, if scnlib
is the root CMake project,
and OFF
otherwise.
$ cd build
# For Debug
$ cmake -DCMAKE_BUILD_TYPE=Debug \
-DSCN_BENCHMARKS_BINARYSIZE=ON \
-DBUILD_SHARED_LIBS=ON ..
# For Release and MinSizeRel,
# add -DCMAKE_BUILD_TYPE=$BUILD_TYPE and
# -DCMAKE_INTERPROCEDURAL_OPTIMIZATION=ON
$ cmake --build .
$ ./benchmark/binarysize/run_binarysize_bench.py ./benchmark/binarysize $BUILD_TYPE
Time is in seconds of CPU time (user time + sys/kernel time). Lower is better.
Method | Debug | Release |
---|---|---|
empty | 0.05 | 0.05 |
scanf |
0.22 | 0.20 |
<iostream> |
0.28 | 0.27 |
scn::input |
0.54 | 0.45 |
Memory is in mebibytes (MiB) used while compiling. Lower is better.
Method | Debug | Release |
---|---|---|
empty | 21.0 | 23.3 |
scanf |
56.3 | 53.6 |
<iostream> |
67.8 | 65.0 |
scn::input |
102 | 91.0 |
Code using scnlib takes around 2x longer to compile compared to <iostream>
,
and also uses around 1.5x more memory.
Release builds seem to be slightly faster as compared to Debug builds.
This tests measures the time it takes to compile a binary, when using different libraries. The time taken to compile the library itself is not taken into account (the standard library is precompiled, anyway).
These tests were run on a Fedora 40 machine, with an AMD Ryzen 7 5700X
processor, using gcc version 14.1.1.
The compiler flags used for a Debug build were -g
, and -O3 -DNDEBUG
for a
Release build.
You can run these benchmarks yourself by enabling the CMake
variable SCN_BENCHMARKS_BUILDTIME
.
This variable is ON
by default, if scnlib
is the root CMake project,
and OFF
otherwise.
In order for these tests to work, c++
must point to a gcc-compatible C++
compiler binary,
and a somewhat POSIX-compatible /usr/bin/time
must be available.
$ cd build
$ cmake -DSCN_BENCMARKS_BUILDTIME=ON ..
$ cmake --build .
$ ./benchmark/buildtime/run-buildtime-tests.sh
The contents of this library are heavily influenced by {fmt} and its derivative
works.
https://github.com/fmtlib/fmt
The design of this library is also inspired by the Python parse
library:
https://github.com/r1chardj0n3s/parse
fast_float for floating-point number parsing:
https://github.com/fastfloat/fast_float
NanoRange for a minimal <ranges>
implementation:
https://github.com/tcbrindle/NanoRange
scnlib is licensed under the Apache License, version 2.0.
Copyright (c) 2017 Elias Kosunen
See LICENSE for further details.