The C++ standard makes certain threading guarantees for all the classes in the standard C++ library. These guarantees may not be what you’d expect them to be but for all standard C++ library classes certain thread safety guarantees are made. Make sure you read the guarantees made, though, as the threading guarantees of standard C++ … Read more
I don’t know of any implementation in a major library, but it looked like an interesting problem so I wrote a basic implementation. I’ve only tested it with the test case I present here, so I don’t recommend using it without further testing. The problem is a bit trickier than it looks because some of … Read more
Well, just do it like the boost guys did it: template <class T> inline void hash_combine(std::size_t& seed, const T& v) { std::hash<T> hasher; seed ^= hasher(v) + 0x9e3779b9 + (seed<<6) + (seed>>2); }
This is implementation dependent: Standard 23.1.2.8: The insert members shall not affect the validity of iterators and references to the container, and the erase members shall invalidate only iterators and references to the erased elements. Maybe you could try this — this is standard conforming: for (auto it = numbers.begin(); it != numbers.end(); ) { … Read more
I think you can use std::vector with OpenMP most of the time and still have good performance. The following code for example fills std::vectors in parallel and then combines them in the end. As long as your main loop/fill function is the bottleneck this should work well in general and be thread safe. std::vector<int> vec; … Read more
If you have only 50 values in std::map you could copy them to std::vector before printing out and sort via std::sort using appropriate functor. Or you could use boost::multi_index. It allows to use several indexes. In your case it could look like the following: struct value_t { string s; int i; }; struct string_tag {}; … Read more
Even though correct answers have already been posted, I thought I’d add a demo of how you can do this cleanly: template<typename A, typename B> std::pair<B,A> flip_pair(const std::pair<A,B> &p) { return std::pair<B,A>(p.second, p.first); } template<typename A, typename B> std::multimap<B,A> flip_map(const std::map<A,B> &src) { std::multimap<B,A> dst; std::transform(src.begin(), src.end(), std::inserter(dst, dst.begin()), flip_pair<A,B>); return dst; } int main(void) … Read more
It’s compiling because printf isn’t type safe, since it uses variable arguments in the C sense1. printf has no option for std::string, only a C-style string. Using something else in place of what it expects definitely won’t give you the results you want. It’s actually undefined behaviour, so anything at all could happen. The easiest … Read more
Here’s a working example based on the range-v3 Library that has been proposed for Standardization #include <range/v3/all.hpp> #include <iostream> using namespace ranges; int main() { std::vector<int> a1{15, 7, 3, 5}; std::vector<int> a2{ 1, 2, 6, 21}; sort(view::zip(a1, a2), std::less<>{}, &std::pair<int, int>::first); std::cout << view::all(a1) << ‘\n’; std::cout << view::all(a2) << ‘\n’; } Live Example (requires … Read more
template<class F> function(F f); template <class F, class A> function(allocator_arg_t, const A& a, F f); Requires: F shall be CopyConstructible. f shall be Callable for argument types ArgTypes and return type R. The copy constructor and destructor of A shall not throw exceptions. ยง20.9.11.2.1 [func.wrap.func.con] Note that operator = is defined in terms of this … Read more