如果您还想启用一个接受参数的构造函数，这可能会有所帮助。

#include <memory>
#include <utility>

template<typename S>
struct enable_make : public S
{
    template<typename... T>
    enable_make(T&&... t)
        : S(std::forward<T>(t)...)
    {
    }
};

class foo
{
public:
    static std::unique_ptr<foo> create(std::unique_ptr<int> u, char const* s)
    {
        return std::make_unique<enable_make<foo>>(std::move(u), s);
    }
protected:
    foo(std::unique_ptr<int> u, char const* s)
    {
    }
};

void test()
{
    auto fp = foo::create(std::make_unique<int>(3), "asdf");
}

问题的根源在于，如果你加为好友的函数或类对你的构造函数进行低级调用，那么它们也必须加为好友。Std::make_shared并不是真正调用构造函数的函数，因此添加为好友并没有什么区别。

class A;
typedef std::shared_ptr<A> APtr;
class A
{
    template<class T>
    friend class std::_Ref_count_obj;
public:
    APtr create()
    {
        return std::make_shared<A>();
    }
private:
    A()
    {}
};

std::_Ref_count_obj实际上是在调用你的构造函数，所以它需要是一个友函数。因为这有点晦涩，所以我使用宏

#define SHARED_PTR_DECL(T) \
class T; \
typedef std::shared_ptr<T> ##T##Ptr;

#define FRIEND_STD_MAKE_SHARED \
template<class T> \
friend class std::_Ref_count_obj;

然后你的类声明看起来相当简单。如果你愿意，你可以创建一个宏来声明ptr和类。

SHARED_PTR_DECL(B);
class B
{
    FRIEND_STD_MAKE_SHARED
public:
    BPtr create()
    {
        return std::make_shared<B>();
    }
private:
    B()
    {}
};

这实际上是一个很重要的问题。 为了使代码可维护、可移植，您需要隐藏尽可能多的实现。

typedef std::shared_ptr<A> APtr;

隐藏了你如何处理智能指针，你必须确保使用你的typedef。但是如果您总是必须使用make_shared来创建一个，这就违背了目的。

上面的示例强制使用类的代码使用智能指针构造函数，这意味着如果您切换到新的智能指针类型，您只需更改类声明，就有很大的机会完成任务。不要以为你的下一个老板或下一个项目会使用stl、boost等。

做了将近30年，我付出了巨大的时间代价、痛苦和副作用来修复多年前做错的事情。

struct A {
public:
  template<typename ...Arg> std::shared_ptr<A> static create(Arg&&...arg) {
    struct EnableMakeShared : public A {
      EnableMakeShared(Arg&&...arg) :A(std::forward<Arg>(arg)...) {}
    };
    return std::make_shared<EnableMakeShared>(std::forward<Arg>(arg)...);
  }
  void dump() const {
    std::cout << a_ << std::endl;
  }
private:
  A(int a) : a_(a) {}
  A(int i, int j) : a_(i + j) {}
  A(std::string const& a) : a_(a.size()) {}
  int a_;
};

因为我不喜欢已经提供的答案，所以我决定继续搜索，并找到了一个解决方案，它不像之前的答案那么通用，但我更喜欢它(tm)。回想起来，它并不比Omnifarius提供的好多少，但可能也有其他人喜欢它:)

这不是我发明的，而是Jonathan Wakely (GCC开发人员)的想法。

不幸的是，它并不适用于所有的编译器，因为它依赖于std::allocate_shared实现中的一个小变化。但是这个变化现在是针对标准库的建议更新，所以将来可能会得到所有编译器的支持。它适用于GCC 4.7。

c++标准库工作组变更请求如下: http://lwg.github.com/issues/lwg-active.html#2070

GCC补丁的用法示例如下: http://old.nabble.com/Re%3A--v3--Implement-pointer_traits-and-allocator_traits-p31723738.html

解决方案的思想是使用std::allocate_shared(而不是std::make_shared)和一个自定义分配器，该分配器被声明为具有私有构造函数的类的友元。

OP的示例如下所示:

#include <memory>

template<typename Private>
struct MyAlloc : std::allocator<Private>
{
    void construct(void* p) { ::new(p) Private(); }
};

class A {
    public:
        static ::std::shared_ptr<A> create() {
            return ::std::allocate_shared<A>(MyAlloc<A>());
        }

    protected:
        A() {}
        A(const A &) = delete;
        const A &operator =(const A &) = delete;

        friend struct MyAlloc<A>;
};

int main() {
    auto p = A::create();
    return 0;
}

一个基于我正在使用的实用程序的更复杂的示例。在这种情况下，我不能使用卢克的解决方案。但Omnifarius的作品可以改编。在前面的例子中，每个人都可以使用MyAlloc创建A对象，但在这个例子中，除了create()方法之外，没有其他方法可以创建A或B对象。

#include <memory>

template<typename T>
class safe_enable_shared_from_this : public std::enable_shared_from_this<T>
{
    public:
    template<typename... _Args>
        static ::std::shared_ptr<T> create(_Args&&... p_args) {
            return ::std::allocate_shared<T>(Alloc(), std::forward<_Args>(p_args)...);
        }

    protected:
    struct Alloc : std::allocator<T>
    {  
        template<typename _Up, typename... _Args>
        void construct(_Up* __p, _Args&&... __args)
        { ::new((void *)__p) _Up(std::forward<_Args>(__args)...); }
    };
    safe_enable_shared_from_this(const safe_enable_shared_from_this&) = delete;
    safe_enable_shared_from_this& operator=(const safe_enable_shared_from_this&) = delete;
};

class A : public safe_enable_shared_from_this<A> {
    private:
        A() {}
        friend struct safe_enable_shared_from_this<A>::Alloc;
};

class B : public safe_enable_shared_from_this<B> {
    private:
        B(int v) {}
        friend struct safe_enable_shared_from_this<B>::Alloc;
};

int main() {
    auto a = A::create();
    auto b = B::create(5);
    return 0;
}

查看20.7.2.2.6 shared_ptr创建[util.smartptr.shared]中std::make_shared的需求。Create]，第1段:

要求:表达式::new (pv) T(std::forward<Args>(Args)…)，其中pv具有void*类型，并且指向适合存储T类型对象的存储空间，必须是格式良好的。A应该是一个分配器(17.6.3.5)。A的复制构造函数和析构函数不能抛出异常。

因为要求在表达上是无条件的，像范围这样的东西没有被考虑在内，我认为像友谊这样的技巧是正确的。

一个简单的解决方案是从A派生。这并不需要将A变成一个接口，甚至是一个多态类型。

// interface in header
std::shared_ptr<A> make_a();

// implementation in source
namespace {

struct concrete_A: public A {};

} // namespace

std::shared_ptr<A>
make_a()
{
    return std::make_shared<concrete_A>();
}

如果您还想启用一个接受参数的构造函数，这可能会有所帮助。

#include <memory>
#include <utility>

template<typename S>
struct enable_make : public S
{
    template<typename... T>
    enable_make(T&&... t)
        : S(std::forward<T>(t)...)
    {
    }
};

class foo
{
public:
    static std::unique_ptr<foo> create(std::unique_ptr<int> u, char const* s)
    {
        return std::make_unique<enable_make<foo>>(std::move(u), s);
    }
protected:
    foo(std::unique_ptr<int> u, char const* s)
    {
    }
};

void test()
{
    auto fp = foo::create(std::make_unique<int>(3), "asdf");
}