What to use unique_ptr or move semantic? - c++11

Question

For example I have a class MyClass and two other classes that process the object of MyClass.
Class A - Creates MyClass;
Class B - uses MyClass;
What is the proper way to store and share the MyClass object among A and B. Need to create MyClass with new operator and store the pointer in unique_ptr. Or implement move c-tor, and create MyClass as stack variable?
Variant 1:
class A
{
public :
unique_ptr<MyClass> mObj;
};
class B
{
B( unique_ptr<MyClass> inObj ) : mObj( inObj ) {};
public :
unique_ptr<MyClass> mObj;
}
Variant 2:
class A
{
public :
MyClass mObj;
};
class B
{
B( MyClass&& inObj ) : mObj( inObj ) {};
public :
MyClass mObj;
};
Using:
A a;
B( a.mObj );

Answer 1

In both of your examples class A can not use myObj after B has taken over! This may not be what you what. However if it is intended, than I would recommend using unique_ptr. Here it is clear, if and when A has lost access to myObj. You can test for is by checking if myObj is a null pointer.

Answer 2

Neither of proposed solutions are going to work, because both as member variable, and with unique_ptr, you have two independent objects.
If you need to access the same object, either use std::shared_ptr, or use references.
With shared_ptr :
class A
{
public :
A() : mpObj( new MyClass ) {}
shared_ptr<MyClass> mpObj;
};
class B
{
public :
B( shared_ptr<MyClass> inObj ) : mpObj( inObj ) ;
shared_ptr<MyClass> mpObj;
};
Another option is to use references :
class A
{
public :
A() : mpObj() {}
MyClass mpObj;
};
class B
{
public :
B( MyClass& inObj ) : mpObj( inObj ) ;
MyClass& mpObj;
};
What is important is to say who creates and initialize the MyClass object.
Also, read about Dependency injection.