Skip to main content

STL short / one liners

A very nice collection of wrappers is available on Stackoverflow.

1. Copy everything in the a container to std::cout (e.g. std::set<std::string> c; )
std::copy (c.begin(), c.end(), std::ostream_iterator <std::string> (std::cout, "\n"));

2. Clear vector v and minimize its capacity (potential number of elements it can hold without resizing).
vector <std::string>().swap (v); Yes! It is a swap with an empty temporary!!

3. Remove all integers of value = 0xDeadBeef;
std::erase (std::remove (c.begin(), c.end(), value), c.end());
This is known as erase-remove idiom.

4. Invoke a member function on all the elements of the container.
std::for_each (c.begin(), c.end(), std::mem_fun (&Class::function));

5. Copy one container to other
std::copy(V.begin(), V.end(), L.begin());

6. Fill an array with random numbers
std::generate(V.begin(), V.end(), rand);

7. Read a file of integers in a set
std::istream_iterator <int> data_begin (std::cin), data_end;
std::set <int> S (data_begin, data_end);

OR
std::set <int> data ((istream_iterator <int> (datafile)),istream_iterator <int> ());

OR
istream_iterator <int> start (cin), end;
copy (start, end, std::back_inserter (v));

8. Reading entire file in one go.

Solution 1:
std::istreambuf_iterator < char > begin(std::cin), end;
std::string str(begin, end);

Solution 2:
std::ostringstream temp;
std::ifstream infile ("file.txt");
temp << infile.rdbuf();
std::string str = temp.str();

Comments

rduht said…
Your Best Choice! wow power leveling and wow gold wow gold

Popular posts from this blog

Multi-dimensional arrays in C++11

What new can be said about multi-dimensional arrays in C++? As it turns out, quite a bit! With the advent of C++11, we get new standard library class std::array. We also get new language features, such as template aliases and variadic templates. So I'll talk about interesting ways in which they come together.

It all started with a simple question of how to define a multi-dimensional std::array. It is a great example of deceptively simple things. Are the following the two arrays identical except that one is native and the other one is std::array?

int native[3][4];
std::array<std::array<int, 3>, 4> arr;

No! They are not. In fact, arr is more like an int[4][3]. Note the difference in the array subscripts. The native array is an array of 3 elements where every element is itself an array of 4 integers. 3 rows and 4 columns. If you want a std::array with the same layout, what you really need is:

std::array<std::array<int, 4>, 3> arr;

That's quite annoying for two r…

Understanding Fold Expressions

C++17 has an interesting new feature called fold expressions. Fold expressions offer a compact syntax to apply a binary operation to the elements of a parameter pack. Here’s an example. template <typename... Args> auto addall(Args... args) { return (... + args); } addall(1,2,3,4,5); // returns 15. This particular example is a unary left fold. It's equivalent to ((((1+2)+3)+4)+5). It reduces/folds the parameter pack of integers into a single integer by applying the binary operator successively. It's unary because it does not explicitly specify an init (a.k.a. identity) argument. So, let add it. template <typename... Args> auto addall(Args... args) { return (0 + ... + args); } addall(1,2,3,4,5); // returns 15. This version of addall is a binary left fold. The init argument is 0 and it's redundant (in this case). That's because this fold expression is equivalent to (((((0+1)+2)+3)+4)+5). Explicit identity elements will come in handy a little la…

Folding Monadic Functions

In the previous two blog posts (Understanding Fold Expressions and Folding Functions) we looked at the basic usage of C++17 fold expressions and how simple functions can be folded to create a composite one. We’ll continue our stride and see how "embellished" functions may be composed in fold expressions.

First, let me define what I mean by embellished functions. Instead of just returning a simple value, these functions are going to return a generic container of the desired value. The choice of container is very broad but not arbitrary. There are some constraints on the container and once you select a generic container, all functions must return values of the same container. Let's begin with std::vector.
// Hide the allocator template argument of std::vector. // It causes problems and is irrelevant here. template <class T> struct Vector : std::vector<T> {}; struct Continent { }; struct Country { }; struct State { }; struct City { }; auto get_countries…