The atomic “thing” in shared_ptr is not the shared pointer itself, but the control block it points to. meaning that as long as you don’t mutate the shared_ptr across multiple threads, you are ok. do note that copying a shared_ptr only mutates the control block, and not the shared_ptr itself. std::shared_ptr<int> ptr = std::make_shared<int>(4); for … Read more
1) First code sample { static std::mutex io_mutex; std::lock_guard<std::mutex> lk(io_mutex); std::cout << e1.id << ” and ” << e2.id << ” are waiting for locks” << std::endl; } This is a standard lock guard, when the scope is exited, the lock lk is released { std::unique_lock<std::mutex> lk1(e1.m, std::defer_lock); std::unique_lock<std::mutex> lk2(e2.m, std::defer_lock); std::lock(lk1, lk2); std::cout << … Read more
You could refactor or wrap f to return a new X instead of having it passed, since this would play pack expansion into the hand and make the function really concise: template<class T> X fw(T const& t){ X x; f(x, t); return x; } template<class… Args> void h(Args… args){ X xs[] = { fw(args)… }; … Read more
Disclaimer: ‘stack’ is not part of the c++ standard to my knowledge, there we have ASDVs (automatic storage duration variables). ABI might define stack. Note that sometimes these are passed in registers, which I believe is OK in your case. Define a CPS (continuation-passing style) factory method: class A { public: template<typename F, typename… Args> … Read more
C++11 introduces to_string() functions: my_func(“bla bla bla” + to_string(my_int) + “bla bla bla”);
Yes, this is perfectly safe: std::queue<T> q; // add stuff… T top = std::move(q.front()); q.pop(); pop() doesn’t have any preconditions on the first element in the q having a specified state, and since you’re not subsequently using q.front() you don’t have to deal with that object being invalidated any more. Sounds like a good idea … Read more
For pre-C++17: template<class Mutex> std::lock_guard<Mutex> make_lock_guard(Mutex& mutex) { mutex.lock(); return { mutex, std::adopt_lock }; } Use as: std::mutex someMutex; auto&& lg = make_lock_guard(someMutex); This takes advantage of the fact that copy-list-initialization doesn’t create an additional temporary (even conceptually). The one-parameter constructor is explicit and can’t be used for copy-list-initialization, so we lock the mutex first … Read more
My personal preference: just keep the extra index. It’s clear as it is, and in case you ever have an if() inside the loop, you can also easily skip the count: std::list<std::string> items; { int i = 0; for (auto & item : items) { if (some_condition(item)) { item += std::to_string(i); // mark item as … Read more
decltype (MyFunction_1) will give you the type of MyFunction_1 (i.e. the function type std::tuple<int, bool, double> ()), you need to emulate a function calling 1 (via adding ()) to get the return type (i.e. std::tuple<int, bool, double>), e.g. void MyFunction_2 (decltype (MyFunction_1()) ¶ms); // ^^ 1 The expression is evaluated at compile-time, the function won’t … Read more
std::random_device may be expensive to create. It may open a device feeding it data, and that takes some time. It can also be expensive to call because it requires entropy to deliver a truly random number, not a pseudo random number. uniform_int_distribution is never expensive to create. It’s designed to be cheap. It does have … Read more