This will print out all elements, get max could be implemented similarly template <int N> void foo(){ cout << N << endl; } template <int N, int M, int … Rest> void foo(){ cout << N << endl; foo<M, Rest…>(); } int main(){ foo<1, 5, 7>(); return 0; }
In a class that provides reference-getters, ref-qualifier overloading can activate move semantics when extracting from an rvalue. E.g.: class some_class { huge_heavy_class hhc; public: huge_heavy_class& get() & { return hhc; } huge_heavy_class const& get() const& { return hhc; } huge_heavy_class&& get() && { return std::move(hhc); } }; some_class factory(); auto hhc = factory().get(); This does … Read more
pre-increment introduces a data dependency into your code — the CPU must wait for the increment operation to be completed before its value can be used in the expression.” Is this true? It is mostly true – although perhaps overly strict. Pre increment doesn’t necessarily introduce a data dependency – but it can. A trivial … Read more
You will get statistical bias when you use modulo (%) to map the range of e.g. rand() to another interval. E.g suppose rand() maps uniformly (without bias) to [0, 32767] and you want to map to [0,4] doing rand() % 5. Then the values 0, 1, and 2 will on average be produced 6554 out … Read more
An explicit move constructors can affect compatibility with e.g. Standard algorithms. For instance, std::swap<T> requires that T be MoveConstructible. In turn, MoveConstructible is specified in terms of an expression, namely T u = rv; (where rv is an rvalue of type T). If there is neither a non-explicit copy constructor nor a non-explicit move constructor … Read more
No, there’s nothing directly equivalent to boost::thread_group in C++11. You could use a std::vector<std::thread> if all you want is a container. You can then use either the new for syntax or std::for_each to call join() on each element, or whatever.
Try this: auto ptr = std::make_shared<Func>(std::initializer_list<std::string>{“foo”, “bar”, “baz”}); Clang is not willing to deduce the type of {“foo”, “bar”, “baz”}. I’m currently not sure whether that is the way the language is supposed to work, or if we’re looking at a compiler bug.
That’s indeed an interesting corner case. It only occurs here because you use uint16_t for the unsigned type when you architecture use 32 bits for ìnt Here is a extract from Clause 5 Expressions from draft n4296 for C++14 (emphasize mine): 10 Many binary operators that expect operands of arithmetic or enumeration type cause conversions … Read more
I would have had to vote against your proof-of-concept implementation had it been proposed. I fear it would break the following code, which I’m pretty sure I’ve seen in the wild at least once or twice over the past dozen years. namespace oops { struct foo { foo() : i(0) {} int i; void swap(foo& … Read more
Smart pointers are for managing ownership and lifetime, they allow us (amongst other things) to safely transfer ownership around the various parts of our code. When you pass a const unique_ptr<T>& to a function (irrelevant of whether T is const or not), what it actually means is that the function promises to never modify the … Read more