Creating objects only as shared pointers through a base class 'create'-method

I am trying to achieve that certain objects within my application can only be constructed as shared_ptr's by a call to a static method called "create".

Of course I could do this by directly adding the static 'create' method to all the respective class. However, this would mean I have to repeat very similar code in almost all my classes. A macro would work, but I do not find this very elegant.

I came up with an alternative way of doing this by deriving all classes from a templated 'BaseObject' class that implements the 'create' method and returns the pointer. This almost works, except that std::make_shared cannot access the constructor of its child class when it is protected.

The non-solution would be to make the child class constructor public (see (1) in the example below). But now Foo can be normally constructed again and this would defeat the entire point. An alternative solution would be to friend BaseObject in the child class and make use of shared_ptr directly (see (2) in the example).

Both solutions put extra burden on the implementer of the child class. Since they have to either find an alternative way of making the constructor non-public or put a friend declaration. The (2) solution has the additional problem of not being able to use the more efficient make_shared.

My question: is there a better way of doing this?

template<class T>
class BaseObject
{
public:
    typedef std::shared_ptr<T> SharedPtr;

    template<class... Args>
    static typename BaseObject<T>::SharedPtr create(Args&&... args)
    {
        return std::make_shared<T>(args...);
        //return std::shared_ptr<T>(new T(args...)); (2)
    }
};

class Foo : public BaseObject<Foo>
{
//friend BaseObject<Foo>; (2)

protected: //public (1)
    Foo(int a = 0) : m_foo(a) {}

private:
    int     m_foo;
};


int main(int argc, char* argv[])
{
    Foo::SharedPtr bla = Foo::create(1);
    return 0;
}