查看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>();
}

查看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>

#if defined(__cplusplus) && __cplusplus >= 201103L
#define ALLOW_MAKE_SHARED(x) friend void __gnu_cxx::new_allocator<test>::construct<test>(test*);
#elif defined(_WIN32) || defined(WIN32)
#if defined(_MSC_VER) && _MSC_VER >= 1800
#define ALLOW_MAKE_SHARED(x) friend class std::_Ref_count_obj;
#else
#error msc version does not suport c++11
#endif
#else
#error implement for platform
#endif

class test {
    test() {}
    ALLOW_MAKE_SHARED(test);
public:
    static std::shared_ptr<test> create() { return std::make_shared<test>(); }

};
int main() {
    std::shared_ptr<test> t(test::create());
}

我已经在windows和linux上进行了测试，它可能需要针对不同的平台进行调整。

当两个严格相关的类a和类B一起工作时，会出现一个更麻烦也更有趣的问题。

假设A是“主类”，B是“从类”。如果你想将B的实例化限制为A，你可以将B的构造函数设为private，并将B设为A的友例

class B
{
public:
    // B your methods...

private:
    B();
    friend class A;
};

不幸的是，从a的方法调用std::make_shared<B>()将使编译器抱怨B::B()是私有的。

我对此的解决方案是在B内部创建一个公共Pass虚拟类(就像nullptr_t一样)，它有私有构造函数，与a是朋友，并使B的构造函数为公共，并将Pass添加到它的参数中，就像这样。

class B
{
public:
  class Pass
  {
    Pass() {}
    friend class A;
  };

  B(Pass, int someArgument)
  {
  }
};

class A
{
public:
  A()
  {
    // This is valid
    auto ptr = std::make_shared<B>(B::Pass(), 42);
  }
};

class C
{
public:
  C()
  {
    // This is not
    auto ptr = std::make_shared<B>(B::Pass(), 42);
  }
};

问题的根源在于，如果你加为好友的函数或类对你的构造函数进行低级调用，那么它们也必须加为好友。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年，我付出了巨大的时间代价、痛苦和副作用来修复多年前做错的事情。

这可能是最简单的解决办法。基于Mohit Aron之前的回答，并结合dlf的建议。

#include <memory>

class A
{
public:
    static std::shared_ptr<A> create()
    {
        struct make_shared_enabler : public A {};

        return std::make_shared<make_shared_enabler>();
    }

private:
    A() {}  
};