Mirando los requisitos para std::make_shared en 20.7.2.2.6 shared_ptr creation [util.smartptr.compartir.crear], párrafo 1:

Requiere: La expresión ::new (pv) T(std::forward<Args>(args)...), donde pv tiene tipo void* y apunta al almacenamiento adecuado para sostener un objeto de tipo T, debe estar bien formada. A será un asignador (17.6.3.5). El constructor de copia y el destructor de A no lanzarán excepciones.

Dado que el requisito se especifica incondicionalmente en términos de esa expresión y cosas como el alcance no se tienen en cuenta, creo que trucos como la amistad están a la derecha.

Una solución simple es derivar de A. Esto no necesita hacer A una interfaz o incluso un tipo polimórfico.

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

Posiblemente la solución más simple. Basado en la anterior respuesta de Mohit Aron e incorporando la sugerencia de 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() {}  
};

Aquí hay una buena solución para esto:

#include <memory>

class A {
   public:
     static shared_ptr<A> Create();

   private:
     A() {}

     struct MakeSharedEnabler;   
 };

struct A::MakeSharedEnabler : public A {
    MakeSharedEnabler() : A() {
    }
};

shared_ptr<A> A::Create() {
    return make_shared<MakeSharedEnabler>();
}

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_;
};

¿Qué tal esto?

static std::shared_ptr<A> create()
{
    std::shared_ptr<A> pA(new A());
    return pA;
}

Como no me gustaron las respuestas ya proporcionadas, decidí buscar y encontré una solución que no es tan genérica como las respuestas anteriores, pero me gusta más(tm). En retrospectiva, no es mucho más agradable que el proporcionado por Omnifarius, pero podría haber otras personas a las que también les guste:)

Esto no es inventado por mí, pero es la idea de Jonathan Wakely (desarrollador de GCC).

Desafortunadamente no funciona con todos los compiladores porque se basa en un pequeño cambio en std::implementación allocate_shared. Pero este cambio es ahora una actualización propuesta para las bibliotecas estándar, por lo que podría ser compatible con todos los compiladores en el futuro. Funciona en GCC 4.7.

La solicitud de cambio del Grupo de Trabajo de la Biblioteca estándar de C++ está aquí: http://lwg.github.com/issues/lwg-active.html#2070

El parche GCC con un uso de ejemplo está aquí: http://old.nabble.com/Re%3A--v3--Implement-pointer_traits-and-allocator_traits-p31723738.html

El la solución funciona con la idea de usar std::allocate_shared (en lugar de std:: make_shared) con un asignador personalizado que se declara amigo de la clase con el constructor privado.

El ejemplo del OP se vería así:

#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;
}

Un ejemplo más complejo que se basa en la utilidad en la que estoy trabajando. Con esto no podía usar la solución de Luc. Pero el de Omnifarius podría ser adaptado. No es que mientras que en el ejemplo anterior todo el mundo puede crear un objeto A usando el MyAlloc en esta no hay manera de crear A o B además del método create ().

#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;
}

Me doy cuenta de que este hilo es bastante antiguo, pero encontré una respuesta que no requiere herencia o argumentos adicionales para el constructor que no pude ver en otro lugar. Sin embargo, no es portátil:

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

He probado en Windows y Linux, puede necesitar ajustes para diferentes plataformas.

Si también desea habilitar un constuctor que toma argumentos, esto puede ayudar un poco.

#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");
}

Idealmente, creo que la solución perfecta requeriría adiciones al estándar C++. Andrew Schepler propone lo siguiente:

(Ir aquí para todo el hilo)

Podemos tomar prestada una idea de boost::iterator_core_access. Propongo una nueva clase std::shared_ptr_access sin público o miembros protegidos, y especificar que para std:: make_shared (args...) y std:: alloc_shared(a, args...), el expresiones:: new (pv) T(forward(args)...) y ptr->~T () debe ser bien formado en el contexto de std::shared_ptr_access.

Una implementación de std:: shared_ptr_access podría verse como:

namespace std {
    class shared_ptr_access
    {
        template <typename _T, typename ... _Args>
        static _T* __construct(void* __pv, _Args&& ... __args)
        { return ::new(__pv) _T(forward<_Args>(__args)...); }

        template <typename _T>
        static void __destroy(_T* __ptr) { __ptr->~_T(); }

        template <typename _T, typename _A>
        friend class __shared_ptr_storage;
    };
}

Uso

Si / cuando se agrega lo anterior al estándar, simplemente haríamos:

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

 protected:
   friend class std::shared_ptr_access;
   A() {}
   A(const A &) = delete;
   const A &operator =(const A &) = delete;
};

Si esto también suena como una adición importante al estándar para usted, no dude en agregar sus 2 centavos al Grupo de Google isocpp vinculado.

Hay un problema más peludo e interesante que sucede cuando tienes dos clases estrictamente relacionadas A y B que trabajan juntas.

Digamos que A es la "clase maestra" y B su "esclavo". Si desea restringir la instanciación de B solo a A, haría que el constructor de B sea privado, y el amigo B a A como esto

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

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

Desafortunadamente llamar a std::make_shared<B>() desde un método de A hará que el compilador se queje de que B::B() es privado.

Mi solución a esto es crear un public Pass clase ficticia (al igual que nullptr_t) dentro de B que tiene constructor privado y es amigo de A y hace público el constructor de B y agrega Pass a sus argumentos, así.

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);
  }
};

La raíz del problema es que si la función o clase que tu amigo hace llamadas de nivel inferior a tu constructor, también tienen que ser amigos. std:: make_shared no es la función que realmente llama a su constructor, por lo que no hace ninguna diferencia.

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 en realidad está llamando a su constructor, por lo que necesita ser un amigo. Dado que eso es un poco oscuro, uso una macro

#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;

Entonces su declaración de clase parece bastante simple. Usted puede hacer un solo macro para declarar el ptr y la clase si lo prefiere.

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

Este es en realidad un tema importante. Para hacer que el código portátil sea mantenible, debe ocultar la mayor parte de la implementación posible.

typedef std::shared_ptr<A> APtr;

Oculta un poco cómo está manejando su puntero inteligente, debe asegurarse de usar su typedef. Pero si siempre tienes que crear uno usando make_shared, frustra el propósito.

El ejemplo anterior obliga al código a usar su clase para usar su constructor de puntero inteligente, lo que significa que si cambias a un nuevo tipo de puntero inteligente, cambias tu declaración de clase y tienes una oportunidad decente de terminar. NO asuma que su próximo jefe o proyecto utilizará stl, boost, etc. planea cambiarlo algún día.

Haciendo esto durante casi 30 años, he pagado un gran precio en tiempo, dolor y efectos secundarios para reparar esto cuando se hizo mal hace años.

Puedes usar esto:

class CVal
{
    friend std::shared_ptr<CVal>;
    friend std::_Ref_count<CVal>;
public:
    static shared_ptr<CVal> create()
    {
        shared_ptr<CVal> ret_sCVal(new CVal());
        return ret_sCVal;
    }

protected:
    CVal() {};
    ~CVal() {};
};

#include <iostream>
#include <memory>

class A : public std::enable_shared_from_this<A>
{
private:
    A(){}
    explicit A(int a):m_a(a){}
public:
    template <typename... Args>
    static std::shared_ptr<A> create(Args &&... args)
    {
        class make_shared_enabler : public A
        {
        public:
            make_shared_enabler(Args &&... args):A(std::forward<Args>(args)...){}
        };
        return std::make_shared<make_shared_enabler>(std::forward<Args>(args)...);
    }

    int val() const
    {
        return m_a;
    }
private:
    int m_a=0;
};

int main(int, char **)
{
    std::shared_ptr<A> a0=A::create();
    std::shared_ptr<A> a1=A::create(10);
    std::cout << a0->val() << " " << a1->val() << std::endl;
    return 0;
}