开源软件名称：ryanhaining/cppitertools开源软件地址：https://github.com/ryanhaining/cppitertools开源编程语言：C++ 97.3%开源软件介绍：CPPItertoolsRange-based for loop add-ons inspired by the Python builtins and itertools library. Like itertools and the Python3 builtins, this library uses lazy evaluation wherever possible. Note: Everything is inside the Follow @cppitertools for updates. Build and Test Status
Table of Contentsrange Combinatoric fuctionsproduct RequirementsThis library is header-only and relies only on the C++ standard
library. The only exception is Running testsYou may use either To run tests with scons you must be within the test$ # build and run all tests
test$ scons
test$ ./test_all
test$ # build and run a specific test
test$ scons test_enumerate
test$ ./test_enumerate
test$ valgrind ./test_enumerate
$ bazel test //test:all # runs all tests
$ bazel test //test:test_enumerate # runs a specific testRequirements of passed objectsMost itertools will work with iterables using InputIterators and not copy
or move any underlying elements. The itertools that need ForwardIterators or
have additional requirements are noted in this document. However, the cases
should be fairly obvious: any time an element needs to appear multiple times
(as in Guarantees of implementationsBy implementations, I mean the objects returned by the API's functions. All of the implementation classes are move-constructible, not copy-constructible, not assignable. All iterators that work over another iterable are tagged as InputIterators and behave as such. FeedbackIf you find anything not working as you expect, not compiling when you believe it should, a divergence from the python itertools behavior, or any sort of error, please let me know. The preferable means would be to open an issue on GitHub. If you want to talk about an issue that you don't feel would be appropriate as a GitHub issue (or you just don't want to open one), you can email me directly with whatever code you have that describes the problem; I've been pretty responsive in the past. If I believe you are "misusing" the library, I'll try to put the blame on myself for being unclear in this document and take the steps to clarify it. So please, contact me with any concerns, I'm open to feedback. How (not) to use this libraryThe library functions create and return objects that are properly templated on the iterable they are passed. These exact names of these types or precisely how they are templated is unspecified, you should rely on the functions described in this document. If you plan to use these functions in very simple, straight forward means as in the examples on this page, then you will be fine. If you feel like you need to open the header files, then I've probably under-described something, let me know. Handling of rvalues vs lvaluesThe rules are pretty simple, and the library can be largely used without knowledge of them. Let's take an example std::vector<int> vec{2,4,6,8};
for (auto&& p : enumerate(vec)) { /* ... */ }In this case, If an rvalue was passed to enumerate, binding a reference would be unsafe. Consider: for (auto&& p : enumerate(std::vector<int>{2,4,6,8})) { /* ... */ }Instead, Pipe syntaxWherever it makes sense, I've implemented the "pipe" operator that has become common in similar libraries. When the syntax is available, it is done by pulling out the iterable from the call and placing it before the tool. For example: filter(pred, seq); // regular call
seq | filter(pred); // pipe-style
enumerate(seq); // regular call
seq | enumerate; // pipe-style.The following tools support pipe. The remaining I left out because although some of them have multiple reasonable versions, it wasn't obvious to me how I would expect them to behave:
I don't personally care for the piping style, but it seemed to be desired by the users. rangeUses an underlying iterator to achieve the same effect of the python range
function. Only the stopping point is provided. Prints for (auto i : range(10)) {
cout << i << '\n';
}The start and stop are both provided. Prints for (auto i : range(10, 15)) {
cout << i << '\n';
}The start, stop, and step are all provided. Prints for (auto i : range(20, 30, 2)) {
cout << i << '\n';
}Negative values are allowed as well. Prints for (auto i : range(2, -3, -1)) {
cout << i << '\n';
}A step size of 0 results in an empty range (Python's raises an exception). The following prints nothing for (auto i : range(0, 10, 0)) {
cout << i << '\n';
}In addition to normal integer range operations, doubles and other numeric types are supported through the template Prints: for(auto i : range(5.0, 10.0, 0.5)) {
cout << i << '\n';
}Implementation Note: Typical ranges have their current value incremented by
the step size repeatedly (
enumerateContinually "yields" containers similar to pairs. They are basic structs with a .index and a .element, and also work with structured binding declarations. Usage appears as: vector<int> vec{2, 4, 6, 8};
for (auto&& [i, e] : enumerate(vec)) {
cout << i << ": " << e << '\n';
}filterCalled as Prints values greater than 4: vector<int> vec{1, 5, 4, 0, 6, 7, 3, 0, 2, 8, 3, 2, 1};
for (auto&& i : filter([] (int i) { return i > 4; }, vec)) {
cout << i <<'\n';
}
If no predicate is passed, the elements themselves are tested for truth Prints only non-zero values. for(auto&& i : filter(vec)) {
cout << i << '\n';
}filterfalseSimilar to filter, but only prints values that are false under the predicate. Prints values not greater than 4: vector<int> vec{1, 5, 4, 0, 6, 7, 3, 0, 2, 8, 3, 2, 1};
for (auto&& i : filterfalse([] (int i) { return i > 4; }, vec)) {
cout << i <<'\n';
}
If no predicate is passed, the elements themselves are tested for truth. Prints only zero values. for(auto&& i : filterfalse(vec)) {
cout << i << '\n';
}
unique_everseenAdditional Requirements: Underlying values must be copy-constructible. This is a filter adaptor that only generates values that have never been seen
before. For this to work your object must be specialized for Prints vector<int> v {1,2,3,4,3,2,1,5,6,7,7,8,9,8,9,6};
for (auto&& i : unique_everseen(v)) {
cout << i << ' ';
}unique_justseenAnother filter adaptor that only omits consecutive duplicates. Prints vector<int> v {1,1,1,2,2,3,3,3,4,3,2,1,1,1};
for (auto&& i : unique_justseen(v)) {
cout << i << ' ';
}takewhileYields elements from an iterable until the first element that is false under the predicate is encountered. Prints vector<int> ivec{1, 2, 3, 4, 5, 6, 7, 6, 5, 4, 3, 2, 1};
for (auto&& i : takewhile([] (int i) {return i < 5;}, ivec)) {
cout << i << '\n';
}dropwhileYields all elements after and including the first element that is true under the predicate. Prints vector<int> ivec{1, 2, 3, 4, 5, 6, 7, 1, 2};
for (auto&& i : dropwhile([] (int i) {return i < 5;}, ivec)) {
cout << i << '\n';
}cycleAdditional Requirements: Input must have a ForwardIterator Repeatedly produces all values of an iterable. The loop will be infinite, so a
Prints vector<int> vec{1, 2, 3};
for (auto&& i : cycle(vec)) {
cout << i << '\n';
if (some_condition) {
break;
}
}repeatRepeatedly produces a single argument forever, or a given number of times.
The below prints for (auto&& e : repeat(1, 5)) {
cout << e << '\n';
}The below prints for (auto&& e : repeat(2)) {
cout << e << '\n';
}countEffectively a Technical limitations: Unlike Python which can use its long integer
types when needed, The below will print for (auto&& i : count()) {
cout << i << '\n';
}groupbyAdditional Requirements: If the Input's iterator's Separate an iterable into groups sharing a common key. The following example creates a new group whenever a string of a different length is encountered. vector<string> vec = {
"hi", "ab", "ho",
"abc", "def",
"abcde", "efghi"
};
for (auto&& gb : groupby(vec, [] (const string &s) {return s.length(); })) {
cout << "key: " << gb.first << '\n';
cout << "content: ";
for (auto&& s : gb.second) {
cout << s << " ";
}
cout << '\n';
}Note: Just like Python's starmapTakes a sequence of tuple-like objects (anything that works with vector<pair<int, int>> v = {{2, 3}, {5, 2}, {3, 4}}; // {base, exponent}
for (auto&& i : starmap([](int b, int e){return pow(b, e);}, v)) {
// ...
}
struct Callable {
int operator()(int i) const;
int operator()(int i, char c) const;
int operator()(double d, int i, char c) const;
};This will work with a tuple of mixed types auto t = make_tuple(
make_tuple(5), // first form
make_pair(3, 'c'), // second
make_tuple(1.0, 1, '1')); // third
for (auto&& i : starmap(Callable{}, t)) {
// ...
}accumulateAdditional Requirements: Type return from functor (with reference removed) must be assignable. Differs from for (auto&& i : accumulate(range(1, 6))) {
cout << i << '\n';
}A second, optional argument may provide an alternative binary function
to compute results. The following example multiplies the numbers, rather
than adding them.
Prints: for (auto&& i : accumulate(range(1, 6), std::multiplies<int>{})) {
cout << i << '\n';
}Note: The intermediate result type must support default construction and assignment. zipTakes an arbitrary number of ranges of different types and efficiently iterates over them in parallel (so an iterator to each container is incremented simultaneously). When you dereference an iterator to "zipped" range you get a tuple of the elements the iterators were holding. Example usage: array<int,4> iseq{{1,2,3,4}};
vector<float> fseq{1.2,1.4,12.3,4.5,9.9};
vector<string> sseq{"i","like","apples","a lot","dude"};
array<double,5> dseq{{1.2,1.2,1.2,1.2,1.2}};
for (auto&& [i, f, s, d] : zip(iseq, fseq, sseq, dseq)) {
cout << i << ' ' << f << ' ' << s << ' ' << d << '\n';
f = 2.2f; // modifies the underlying 'fseq' sequence
}zip_longestTerminates on the longest sequence instead of the shortest.
Repeatedly yields a tuple of vector<int> v1 = {0, 1, 2, 3};
vector<int> v2 = {10, 11};
for (auto&& [x, y] : zip_longest(v1, v2)) {
cout << '{';
if (x) {
cout << "Just " << *x;
} else {
cout << "Nothing";
}
cout << ", ";
if (y) {
cout << "Just " << *y;
} else {
cout << "Nothing";
}
cout << "}\n";
}The output is: imapTakes a function and one or more iterables. The number of iterables must match the number of arguments to the function. Applies the function to each element (or elements) in the iterable(s). Terminates on the shortest sequence. Prints the squares of the numbers in vec: vector<int> vec{1, 2, 3, 4, 5};
for (auto&& i : imap([] (int x) {return x * x;}, vec)) {
cout << i << '\n';
}With more than one sequence, the below adds corresponding elements from
each vector together, printing vector<int> vec1{1, 3, 5, 7, 9, 11};
vector<int> vec2{10, 20, 30, 40, 50, 60};
for (auto&& i : imap([] (int x, int y) { return x + y; }, vec1, vec2)) {
cout << i << '\n';
}Note: The name |
