As a first remark, I wouldn’t call it ObjectArray if it is a map and not an array. Anyway, you can insert objects this way: ObjectArray myMap; myMap.insert(std::make_pair(0, std::unique_ptr<Class1>(new Class1()))); Or this way: ObjectArray myMap; myMap[0] = std::unique_ptr<Class1>(new Class1()); The difference between the two forms is that the former will fail if the key 0 … Read more
std::unique_ptr is the C++11 way to express exclusive ownership, but one of its most attractive features is that it easily and efficiently converts to a std::shared_ptr. This is a key part of why std::unique_ptr is so well suited as a factory function return type. Factory functions can’t know whether callers will want to use exclusive … Read more
std::bind works fine with move-only types. However it creates a move-only functor in the process. std::function requires a copy constructible functor. It sounds like boost::asio does too. When you call the move-only bind functor, it will pass its bound arguments as lvalues to the target operator(). So if one of your bound arguments is move-only, … Read more
You could use Boost.Preprocessor to generate the different parameter counts, but I really don’t see the advantage of that. Simply do the grunt job once, stuff it in a header and be done. You’re saving yourself compile time and have your make_unique. Here‘s a copy-paste of my make_unique.h header that simulates variadic templates for up … Read more
I decided to write up a short program that put a few polymorphic objects into a container (by pointer to heap), and then use that container with a std::algorithm. I chose std::remove_if just as an example. Here is how I would do it with vector<unique_ptr<T>>: #include <vector> #include <memory> #include <iostream> class Animal { public: … Read more
MSVC is right while GCC is wrong: Standard(3.9/5): Incompletely-defined object types and the void types are incomplete types Standard(20.7.1.1.2/4): If T is an incomplete type, the program is ill-formed
Quoting from the original proposal: T[N] As of N3485, unique_ptr doesn’t provide a partial specialization for T[N]. However, users will be strongly tempted to write make_unique<T[N]>(). This is a no-win scenario. Returning unique_ptr<T[N]> would select the primary template for single objects, which is bizarre. Returning unique_ptr<T[]> would be an exception to the otherwise ironclad rule … Read more
If you provide the deleter as template argument (as in unique_ptr) it is part of the type and you don’t need to store anything additional in the objects of this type. If deleter is passed as constructor’s argument (as in shared_ptr) you need to store it in the object. This is the cost of additional … Read more
Please make sure you supply the correct -std flag when compiling. The default setting that Orwell Dev-C++ uses (don’t pass any -std option), will not enable some shiny new C++11 functions, like unique_ptr. The fix is quite simple: For non-project compilations, go to: Tools >> Compiler Options >> (select your compiler) >> Settings >> Code … Read more
I defined a regular function: void stackOfX509Deleter(STACK_OF(X509) *ptr) { sk_X509_free(ptr); } Then I use it in my code: using STACK_OF_X509_ptr = std::unique_ptr<STACK_OF(X509), decltype(&stackOfX509Deleter)>; STACK_OF_X509_ptr chain(loadIntermediate(cert.string()), stackOfX509Deleter);