title: passing unique_ptr to object throws error
body: <p>I am learning builder design pattern and smart pointer.<br>
  So I am trying to use smart_ptr all the way in my code. But when I create instance in main using unique_ptr and pass it to Contractor object it throws error.    </p>
  
  <p>If I replaces unqiue_ptr with shared_ptr in contractor class as well as in main. The prog runs fine but no destructor is called.    </p>
  
  <p>Below are the errors I get when I use unique_ptr.</p>
  
  <pre><code> error: call to implicitly-deleted copy constructor of 'std::unique_ptr&lt;HouseBuilder&gt;'
   Contractor *ctr1 = new Contractor(lavishHouseBldr);
  
  /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/include/c++/v1/memory:2621: copy constructor is implicitly deleted because 'unique_ptr&lt;HouseBuilder, std::__1::default_delete&lt;HouseBuilder&gt; &gt;' has a user-declared move constructor
  _LIBCPP_INLINE_VISIBILITY unique_ptr(unique_ptr&amp;&amp; __u) _NOEXCEPT
                                ^
  passing argument to parameter 'houseBuilder' here
   Contractor(std::unique_ptr&lt;HouseBuilder&gt;houseBuilder): houseBuilder(std::move( houseBuilder))
  </code></pre>
  
  <p>Below are my code..</p>
  
  <pre><code>/* Concrete class for the HousePlan interface */
  class House
  {
  private:
    std::string  window, door, bathroom, floor, kitchen;
  public:
    void setWindow( string window)
    {
        this-&gt;window = window;
    }
    void setDoor( string door)
    {
        this-&gt;door = door;
    }
    ~House()
    {
        cout &lt;&lt;"destructor  House called"&lt;&lt;endl;
    }
  };
  /* Builder class*/
  class HouseBuilder
  {
  public:
      virtual void buildWindow()   = 0;
      virtual void buildDoor()     = 0;
      virtual House* getHouse()    = 0;
      virtual ~HouseBuilder() = 0;
  };
  HouseBuilder::~HouseBuilder()
  {
      std::cout &lt;&lt;"Destructor for housebuilder called";
  }
  class LavishHouse:public HouseBuilder
  {
  public:
    LavishHouse( )
    {
        house.reset(new House());
    }
    ~LavishHouse( )
    {
        cout &lt;&lt;"Lavish House Destructor callled"&lt;&lt;std::endl;
    }
    void buildWindow()
    {
       house-&gt;setWindow(" French Windows");
    }
  
    void buildDoor()
    {
        house-&gt;setDoor(" woodenDoor");
    }
    House* getHouse()
    {
        return  house.get();
    }
  private:
      std::unique_ptr&lt;House&gt; house;
  };
  /* The Director. Consturct director*/
  
  class Contractor
  {
  public:
      Contractor(std::unique_ptr&lt;HouseBuilder&gt;houseBuilder): houseBuilder(std::move( houseBuilder))
      {
  
      }
     /* Contractor(HouseBuilder*houseBuilder): houseBuilder(houseBuilder)
      {
  
      }*/
      ~Contractor()
      {
          cout &lt;&lt;"destruct contractor"&lt;&lt;std::endl;
      }
  
      House *getHouse()
       {
        return houseBuilder-&gt;getHouse();
       }
  
       void buildHouse()
       {
        houseBuilder-&gt;buildWindow();
        houseBuilder-&gt;buildDoor();
       }
  private:
      std::unique_ptr&lt;HouseBuilder&gt; houseBuilder;
  
  };
  
  /* Example on how to use the Builder design pattern */
  int main()
  {
  
  std::unique_ptr&lt; HouseBuilder&gt; lavishHouseBldr( new LavishHouse() );
   Contractor *ctr1 = new Contractor(lavishHouseBldr); // error!!!!!
  
   ctr1-&gt;buildHouse();
   House *house1 = ctr1-&gt;getHouse();
   cout&lt;&lt;"Constructed: "&lt;&lt;house1&lt;&lt; std::endl;
   return 0;
  }
  </code></pre>