title: Is this move and copy wrapper sound and complete?
body: <p>I just made a wrapper for move and copy operations to inject into code to see which is called in case of default implementations. I'm getting close to understanding when what is called but would like to double check at times.</p>
  
  <p>I'm not sure if method 1 of <code>using T::T;</code> is better for the constructors than method 2 of forwarding the arguments like unique_ptr? I found it in this thread <a href="https://stackoverflow.com/questions/3119929/forwarding-all-constructors-in-c0x">Forwarding all constructors in C++0x</a></p>
  
  <p>In move constructor and assignment I use <code>std::move</code> to pass onto the super class. Should this be <code>std::forward</code> and if so, how? I get errors trying to use it.</p>
  
  <pre><code>#ifndef MOVECOPY_OBSERVER_H
  #define MOVECOPY_OBSERVER_H
  
  #include &lt;iostream&gt;
  
  template&lt;class T&gt;
  class MoveCopyObserver : public T {
  public:
      //1: Use "using" for constructors 
      //From https://stackoverflow.com/questions/3119929/forwarding-all-constructors-in-c0x
      using T::T;
  
      //2: Forward all args, unique_ptr style.
      /*
      template&lt;typename... Args&gt;
      MoveCopyObserver(Args&amp;&amp;... args) 
          : T(std::forward&lt;Args&gt;(args)...) 
      {
      };*/
  
      // *************************************************************************
      virtual ~MoveCopyObserver() = default;
  
  
      // *************************************************************************
      MoveCopyObserver(const MoveCopyObserver&amp; other)
          : T(other)
      {
          std::cout &lt;&lt; "Copy constructor " &lt;&lt; typeid(T).name() &lt;&lt; std::endl;
      }
  
  
      // *************************************************************************
      MoveCopyObserver(MoveCopyObserver &amp;&amp; other)
          : T(std::move(other)) //3: std::forward instead?
      {
          std::cout &lt;&lt; "Move constructor " &lt;&lt; typeid(T).name() &lt;&lt; std::endl;
      }
  
  
      // *************************************************************************
      MoveCopyObserver&amp; operator=(const MoveCopyObserver&amp; other)
      {
          T::operator=(other);
          std::cout &lt;&lt; "Copy assignment " &lt;&lt; typeid(T).name() &lt;&lt; std::endl;
          return *this;
      }
  
  
      // *************************************************************************
      MoveCopyObserver&amp; operator=(MoveCopyObserver&amp;&amp; other)
      {
          T::operator=(std::move(other)); //3: std::forward instead?
          std::cout &lt;&lt; "Move assignment " &lt;&lt; typeid(T).name() &lt;&lt; std::endl;
          return *this;
      }
  };
  
  
  #endif //MOVECOPY_OBSERVER_H
  </code></pre>
  
  <p>The usage would be on the stack or through smart pointers, like so:</p>
  
  <pre><code>class A {
  public:
      A(std::string ss)
      {
          s = ss;
      }
  
      void f()
      {
          std::cout &lt;&lt; "\"" &lt;&lt; s &lt;&lt; "\"" &lt;&lt; std::endl;
      }
  
  private:
      std::string s;
  };
  
  A a("Test instance");
  a.foo();
  
  MoveCopyObserver&lt;A&gt; b("Another instance");
  b.foo();
  </code></pre>