If you want a container of strings and want to use the same allocator for the container and its elements (so they are all allocated in the same arena, as TemplateRex describes) then you can do that manually: template<typename T> using Allocator = SomeFancyAllocator<T>; using String = std::basic_string<char, std::char_traits<char>, Allocator<char>>; using Vector = std::vector<String, Allocator<String>>; … Read more
If more than one overload accepts a pointer type, an overload for std::nullptr_t is necessary to accept a nullptr argument. Without the std::nullptr_t overload, it would be ambiguous which pointer overload should be selected when passed nullptr. Example: void f(int *intp) { // Passed an int pointer } void f(char *charp) { // Passed a … Read more
You can use std::transform to do mapping, and std::copy_if for filtering. You have two options for reduce depending on your input and if you want to use a specific type of execution model. I’ve written some simple examples below to demonstrate common use cases. Note that there are multiple overloads for all these algorithms that … Read more
And so, is the one shown by the example a well-defined behavior? Yes, the behaviour shown in the example is the only behaviour allowed by the standard. That is because std::move doesn’t move. The things that move are move constructors and move assignment operators. All std::move does is change an lvalue into an xvalue, so … Read more
You can’t separate declaration and definition of lambdas, neither forward declare it. Its type is a unique unnamed closure type which is declared with the lambda expression. But you could do that with std::function objects, which is designed to be able to store any callable target, including lambdas. As your sample code shown you’ve been … Read more
You need to make the x attribute atomic, and not your whole class, as followed: class A { std::atomic<int> x; public: A() { x=0; } void Add() { x++; } void Sub() { x–; } }; The error you get in you original code is completely normal: there is no std::atomic<A>::Add method (see here) unless … Read more
They are different only wrt the produced diagnostics. If you make it private, an additional and superfluous access violation is reported: class A { public: A() = default; private: A(const A&) = delete; }; int main() { A a; A a2=a; } results in the following additional output from GCC 4.8: main.cpp: In function ‘int … Read more
A conditional base class may be used: struct BaseWithVariable { int addedVariable; }; struct BaseWithoutVariable { }; template <bool AddMembers> class MyClass : std::conditional<AddMembers, BaseWithVariable, BaseWithoutVariable>::type { // etc. };
I once wrote it (EDIT: see below for limitations and explanations). From https://stackoverflow.com/a/10287598/34509 : template<typename T> constexpr typename remove_reference<T>::type makeprval(T && t) { return t; } #define isprvalconstexpr(e) noexcept(makeprval(e)) However there are many kinds of constant expressions. The above answer detects prvalue constant expressions. Explanation The noexcept(e) expression gives false iff e contains a potentially … Read more
I could compile your code successfully with MSVC2013. However, thread() works passing copies of its argument to the new thread. This means that if your code would compile on your compiler, each thread wourd run with its own copy of ht, so that at the end, main‘s ht would be empty. GCC doesn’t compile with … Read more