Return to Answer

• The main point of unique_ptr is that it eliminates ownership problems. When you have a unique_ptr you are the only one who has access to an object and do not need to worry about other code. With regular pointers sometimes you must delete them and sometimes you must not, which is confusing. If someone just calls Inproc::create(); it is already a memory leak which unique_ptrs were meant to prevent:

   std::unique_ptr<Inproc> create();
  

• Avoid functions such as create, init, destroy, copy and clone. C++ has special member functions for that: Constructor, destructor and copy assignment. They cannot always be used, but if they can prefer them. Inpoc::create should actually be a regular constructor. If the construction of an Inproc can fail and you cannot use exceptions provide a member function bool is_valid() const that the caller can use to check if construction worked.

• Prefer nullptr over NULL because nullptr works correctly with templates whereas NULL will occasionally fail.

• Avoid using new and delete. To create a unique_ptr use make_unique and for shared_ptr use make_shared. Somehow the C++11 standard forgot to specify make_unique so if there is no std::make_unique in your STL write your own. You can even write a make_unique_nothrow for your special requirement.

• The main point of unique_ptr is that it eliminates ownership problems. When you have a unique_ptr you are the only one who has access to an object and do not need to worry about other code. With regular pointers sometimes you must delete them and sometimes you must not, which is confusing. If someone just calls Inproc::create(); it is already a memory leak which unique_ptrs were meant to prevent:

   std::unique_ptr<Inproc> create();
  

• Avoid functions such as create, init, destroy, copy and clone. C++ has special member functions for that: Constructor, destructor and copy assignment. They cannot always be used, but if they can prefer them. Inpoc::create should actually be a regular constructor. If the construction of an Inproc can fail and you cannot use exceptions provide a member function bool is_valid() const that the caller can use to check if construction worked.

• Prefer nullptr over NULL because nullptr works correctly with templates whereas NULL will occasionally fail.

• Avoid using new and delete. To create a unique_ptr use make_unique and for shared_ptr use make_shared. Somehow the C++11 standard forgot to specify make_unique so if there is no std::make_unique in your STL write your own. You can even write a make_unique_nothrow for your special requirement.

(削除) There is no need for std::move here because *bound.release() is already a temporary object. (削除ここまで) I screwed that one up. Apparently you do need the move even though * unique_ptr.release() is logically a temporary. Thanks to dyp for pointing it out.

(削除) There is no need for std::move here because *bound.release() is already a temporary object. (削除ここまで) I screwed that one up. (削除) Apparently you do need the move even though * unique_ptr.release() is logically a temporary. (削除ここまで) Thanks to @dyp for pointing it out. release is completely misplaced, that would create a memory leak. This time I tested it.

• Would it be possible to have Inproc(Fan &&bound__, Fan &&connected__); as constructor and still use std::unique_ptr and std::move?
  You can express that:

   Inproc(Fan &&bound__, Fan &&connected__);
   std::unique_ptr<Inproc> Inproc::create(){
   std::unique_ptr<Fan> bound(Fan::create());
   if (bound){
   std::unique_ptr<Fan> connected(Fan::create(bound.get()));
   if (connected){
   //return new(std::nothrow) Inproc(*bound.release(), *connected.release());
   return make_unique_nothrow<Inproc>(*bound.release(), *connected.release());
   }
   }
   return nullptr;
   }
  

There is no need for std::move here because *bound.release() is already a temporary object.

• Would it be possible to have Inproc(Fan &&bound__, Fan &&connected__); as constructor and still use std::unique_ptr and std::move?
  You can express that:

   Inproc(Fan &&bound__, Fan &&connected__);
   std::unique_ptr<Inproc> Inproc::create(){
   std::unique_ptr<Fan> bound(Fan::create());
   if (bound){
   std::unique_ptr<Fan> connected(Fan::create(bound.get()));
   if (connected){
   //return new(std::nothrow) Inproc(std::move(*bound), std::move(*connected));
   return make_unique_nothrow<Inproc>(std::move(*bound), std::move(*connected));
   }
   }
   return nullptr;
   }
  

(削除) There is no need for std::move here because *bound.release() is already a temporary object. (削除ここまで) I screwed that one up. Apparently you do need the move even though * unique_ptr.release() is logically a temporary. Thanks to dyp for pointing it out.