string build_string()
{
 string result;

 //... build code

 return result;
}

//VS2010
#define __STL_MOVE_VALUE(x)      std::move(x)
#define __STL_FORWARD_VALUE(T,x) std::forward<T>(x)

//old compilers
#define __STL_MOVE_VALUE(x) (x)
#define __STL_FORWARD_VALUE(T,x) (x)

//class B is movable
class A
{
public:
  //я чего-то не понимаю или тут реально не нужно && ? ведь это ненужное ограничение на клиента
  void SetB(B&& b)
  {
    m_b = std::move(b);
  }

  B m_b;
};

//variant 1
class A
{
public:
  A& operator=(A&& other)
  {
    CloseResource();
    std::swap(m_Resource, other.m_Resource);
    return *this;
  }

  ~A()
  {
    CloseResource();
  }

private:
  ResourceType m_Resource;
};

//variant 2
class A
{
public:
  A& operator=(A&& other)
  {
    std::swap(m_Resource, other.m_Resource);
  }

  ~A()
  {
    //free resource
  }
private:
  ResourceType m_Resource;
};

//variant 3
class A
{
public:
  A& operator=(A&& other)
  {
    A tmp(std::move(other));
    std::swap(tmp.m_Resource, m_Resource);
    return *this;
  }

private:
  ResourceType m_Resource;
};

//class B is movable
class A
{
 public:
  //я чего-то не понимаю или тут реально не нужно && ? ведь это ненужное ограничение на клиента
  void SetB(B&& b)
  {
    m_b = std::move(b);
  }

  B m_b;
};

КД>string build_string()
КД>{
КД> string result;

КД> //... build code

КД> return result;
КД>}
КД>

When the criteria for elision of a copy operation are met or would be met save for the fact that the source object is a function parameter, and the object to be copied is designated by an lvalue, overload resolution to select the constructor for the copy is first performed as if the object were designated by an rvalue. If overload resolution fails, or if the type of the first parameter of the selected constructor is not an rvalue reference to the object’s type (possibly cv-qualified), overload resolution is performed again, considering the object as an lvalue. [ Note: This two-stage overload resolution must be performed regardless of whether copy elision will occur. It determines the constructor to be called if elision is not performed, and the selected constructor must be accessible even if the call is elided. —end note ]

[ Example:

class Thing {
public:
  Thing();
  ~Thing();
  Thing(Thing&&);
private:
  Thing(const Thing&);
};

Thing f(bool b) {
  Thing t;
  if (b)
    throw t;         // OK: Thing(Thing&&) used (or elided) to throw t
  return t;          // OK: Thing(Thing&&) used (or elided) to return t
}

Thing t2 = f(false); // OK: Thing(Thing&&) used (or elided) to construct t2

—end example ]

КД>>Лично я определяю SetB(B&& b) только в довесок к нормальному "void SetB(const B& b)"

void SetB(B b)
{
 m_std_vector_of_B.push_back(b);
}

void SetB(const B& b)
{
 m_std_vector_of_B.push_back(b);
}

class A
{
public:
  //я чего-то не понимаю или тут реально не нужно && ? ведь это ненужное ограничение на клиента
  void SetB(B&& b)
  {
    m_b = std::move(b);
  }

  B m_b;
};

void SetB(const B& b);
void SetB(B&& b); //добавили. OK

//...

void SetB(B b); //удалили
void SetB(B&& b); //добавили. WRONG -- весь клиентский код переписывать

void SetB(B b);
void SetB(B&& b); //добавили. WRONG -- возможны неоднозначности

 - освобождение ресурсов A
 - перемещение ресурсов B в A

J>Ну да, либо ты делаешь все на вызывающей стороне, либо на вызваемой

B b;
SetB(B(b));
//work with b

о_О>>у GCC вариант 1

U>опачки, это интересно

  void swap(_Myt&& _Right)
  {    // exchange contents with movable _Right
    _Mybase::_Swap(_STD move(_Right));
  }

A &operator=(A &&) noexcept = default;

template <class T> std::move (T& a, T& b)
{
    T c = std::move (a);
    a = std::move (b);
    b = std::move (c);
}

class A
{
public:
    void SetB(B const &b)
    {
        m_b = b;
    }
    void SetB(B &&b)
    {
        m_b = std::move(b);
    }
    // ...
private:
    B m_b;
};

class A
{
public:
    void SetB(B b)
    {
        m_b = std::move(b);
    }
    // ...
private:
    B m_b;
};

struct B
{
    // ...
    B(B const &x);
    B(B &&x);

    B &operator =(B const &x)
    {
        return *this = B(x);
    }
    B &operator =(B &&x);
};

//class B is movable
class A1
{
  B m_b;
public:
  void SetB(B b)
  {
    m_b = std::move(b);
  }
};

class A2
{
  B m_b;
public:
  void SetB(const B& b)
  {
    m_b = b;
  }

  void SetB(B&& b)
  {
    m_b = std::move(b);
  }
};

class A3
{
  B m_b;
public:
  void SetB(B&& b)
  {
    m_b = std::move(b);
  }
};

struct B
M>{
M>    // ...
M>    B(B const &x);
M>    B(B &&x);

M>    B &operator =(B const &x)
M>    {
M>        return *this = B(x);
M>    }
M>    B &operator =(B &&x);
M>};

struct B
{
    // ...
    B(B const &x);
    B(B &&x) noexcept; // или хотя бы throw()

    B &operator =(B const &x)
    {
        return *this = B(x);
    }
    B &operator =(B &&x) noexcept; // или хотя бы throw()
};