Tôi có mã này không hoạt động, nhưng tôi nghĩ mục đích là rõ ràng:

testmakeshared.cpp

#include <memory>

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

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

::std::shared_ptr<A> foo()
{
   return A::create();
}

Nhưng tôi gặp lỗi này khi biên dịch nó:

g++ -std=c++0x -march=native -mtune=native -O3 -Wall testmakeshared.cpp
In file included from /usr/lib/gcc/x86_64-redhat-linux/4.6.1/../../../../include/c++/4.6.1/bits/shared_ptr.h:52:0,
                 from /usr/lib/gcc/x86_64-redhat-linux/4.6.1/../../../../include/c++/4.6.1/memory:86,
                 from testmakeshared.cpp:1:
testmakeshared.cpp: In constructor ‘std::_Sp_counted_ptr_inplace<_Tp, _Alloc, _Lp>::_Sp_counted_ptr_inplace(_Alloc) [with _Tp = A, _Alloc = std::allocator<A>, __gnu_cxx::_Lock_policy _Lp = (__gnu_cxx::_Lock_policy)2u]’:
/usr/lib/gcc/x86_64-redhat-linux/4.6.1/../../../../include/c++/4.6.1/bits/shared_ptr_base.h:518:8:   instantiated from ‘std::__shared_count<_Lp>::__shared_count(std::_Sp_make_shared_tag, _Tp*, const _Alloc&, _Args&& ...) [with _Tp = A, _Alloc = std::allocator<A>, _Args = {}, __gnu_cxx::_Lock_policy _Lp = (__gnu_cxx::_Lock_policy)2u]’
/usr/lib/gcc/x86_64-redhat-linux/4.6.1/../../../../include/c++/4.6.1/bits/shared_ptr_base.h:986:35:   instantiated from ‘std::__shared_ptr<_Tp, _Lp>::__shared_ptr(std::_Sp_make_shared_tag, const _Alloc&, _Args&& ...) [with _Alloc = std::allocator<A>, _Args = {}, _Tp = A, __gnu_cxx::_Lock_policy _Lp = (__gnu_cxx::_Lock_policy)2u]’
/usr/lib/gcc/x86_64-redhat-linux/4.6.1/../../../../include/c++/4.6.1/bits/shared_ptr.h:313:64:   instantiated from ‘std::shared_ptr<_Tp>::shared_ptr(std::_Sp_make_shared_tag, const _Alloc&, _Args&& ...) [with _Alloc = std::allocator<A>, _Args = {}, _Tp = A]’
/usr/lib/gcc/x86_64-redhat-linux/4.6.1/../../../../include/c++/4.6.1/bits/shared_ptr.h:531:39:   instantiated from ‘std::shared_ptr<_Tp> std::allocate_shared(const _Alloc&, _Args&& ...) [with _Tp = A, _Alloc = std::allocator<A>, _Args = {}]’
/usr/lib/gcc/x86_64-redhat-linux/4.6.1/../../../../include/c++/4.6.1/bits/shared_ptr.h:547:42:   instantiated from ‘std::shared_ptr<_Tp1> std::make_shared(_Args&& ...) [with _Tp = A, _Args = {}]’
testmakeshared.cpp:6:40:   instantiated from here
testmakeshared.cpp:10:8: error: ‘A::A()’ is protected
/usr/lib/gcc/x86_64-redhat-linux/4.6.1/../../../../include/c++/4.6.1/bits/shared_ptr_base.h:400:2: error: within this context

Compilation exited abnormally with code 1 at Tue Nov 15 07:32:58

Thông báo này về cơ bản nói rằng một số phương thức ngẫu nhiên đi xuống trong ngăn xếp khởi tạo mẫu từ ::std::make_sharedkhông thể truy cập vào hàm tạo vì nó được bảo vệ.

Nhưng tôi thực sự muốn sử dụng cả hai ::std::make_sharedvà ngăn không cho bất kỳ ai tạo ra một đối tượng của lớp này mà không được chỉ ra bởi a ::std::shared_ptr. Có cách nào để thực hiện điều này?

Câu trả lời này có lẽ tốt hơn, và câu trả lời tôi sẽ chấp nhận. Nhưng tôi cũng đã đưa ra một phương thức xấu hơn, nhưng vẫn để mọi thứ vẫn là nội tuyến và không yêu cầu lớp dẫn xuất:

#include <memory>
#include <string>

class A {
 protected:
   struct this_is_private;

 public:
   explicit A(const this_is_private &) {}
   A(const this_is_private &, ::std::string, int) {}

   template <typename... T>
   static ::std::shared_ptr<A> create(T &&...args) {
      return ::std::make_shared<A>(this_is_private{0},
                                   ::std::forward<T>(args)...);
   }

 protected:
   struct this_is_private {
       explicit this_is_private(int) {}
   };

   A(const A &) = delete;
   const A &operator =(const A &) = delete;
};

::std::shared_ptr<A> foo()
{
   return A::create();
}

::std::shared_ptr<A> bar()
{
   return A::create("George", 5);
}

::std::shared_ptr<A> errors()
{
   ::std::shared_ptr<A> retval;

   // Each of these assignments to retval properly generates errors.
   retval = A::create("George");
   retval = new A(A::this_is_private{0});
   return ::std::move(retval);
}

Chỉnh sửa 2017-01-06: Tôi đã thay đổi điều này để làm rõ rằng ý tưởng này rõ ràng và đơn giản có thể mở rộng cho các nhà xây dựng có lập luận vì những người khác đang cung cấp câu trả lời dọc theo những dòng đó và có vẻ bối rối về điều này.

Xem xét các yêu cầu đối với std::make_sharedviệc tạo 20.7.2.2.6 shared_ptr [produc.smartptr. Shared.create], đoạn 1:

Yêu cầu: Biểu thức ::new (pv) T(std::forward<Args>(args)...), trong đó pvcó loại void*và các điểm để lưu trữ phù hợp để giữ một đối tượng của loại T, sẽ được hình thành tốt. Asẽ là một người cấp phát (17.6.3.5). Các constructor sao chép và hàm hủy của Asẽ không ném ngoại lệ.

Vì yêu cầu được quy định vô điều kiện theo biểu thức đó và những điều như phạm vi không được tính đến, tôi nghĩ rằng các thủ thuật như tình bạn là đúng đắn.

Một giải pháp đơn giản là xuất phát từ A. Điều này không cần phải tạo Agiao diện hoặc thậm chí là một loại đa hình.

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

Có thể là giải pháp đơn giản nhất. Dựa trên câu trả lời trước của Mohit Aron và kết hợp đề xuất của 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() {}  
};

Đây là một giải pháp gọn gàng cho việc này:

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

Còn cái này thì sao?

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

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

Vì tôi không thích câu trả lời đã được cung cấp, tôi quyết định tìm kiếm và tìm ra giải pháp không chung chung như câu trả lời trước nhưng tôi thích nó hơn (tm). Nhìn lại, nó không đẹp hơn nhiều so với Omnifarius cung cấp nhưng cũng có thể có những người khác cũng thích nó :)

Đây không phải là phát minh của tôi, nhưng đó là ý tưởng của Jonathan Wakely (nhà phát triển GCC).

Thật không may, nó không hoạt động với tất cả các trình biên dịch vì nó phụ thuộc vào một thay đổi nhỏ trong việc thực hiện std :: allocate_ Shared. Nhưng thay đổi này hiện là bản cập nhật được đề xuất cho các thư viện tiêu chuẩn, vì vậy nó có thể được hỗ trợ bởi tất cả các trình biên dịch trong tương lai. Nó hoạt động trên GCC 4.7.

Yêu cầu thay đổi nhóm làm việc thư viện tiêu chuẩn C ++ tại đây: http://lwg.github.com/issues/lwg-active.html#2070

Bản vá GCC với cách sử dụng ví dụ có tại đây: http://old.nabble.com/Re%3A--v3--Imcellence-pulum_traits-and-allocator_traits-p31723738.html

Giải pháp hoạt động dựa trên ý tưởng sử dụng std :: allocate_ Shared (thay vì std :: make_ Shared) với một cấp phát tùy chỉnh được khai báo là bạn với lớp với hàm tạo riêng.

Ví dụ từ OP sẽ như thế này:

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

Một ví dụ phức tạp hơn dựa trên tiện ích tôi đang làm việc. Với điều này, tôi không thể sử dụng giải pháp của Luc. Nhưng một trong những Omnifarius có thể được điều chỉnh. Không phải là trong ví dụ trước, mọi người đều có thể tạo một đối tượng A bằng cách sử dụng MyAlloc trong trường hợp này, không có cách nào để tạo A hoặc B ngoài phương thức tạo ().

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

Lý tưởng nhất, tôi nghĩ rằng giải pháp hoàn hảo sẽ yêu cầu bổ sung cho tiêu chuẩn C ++. Andrew Schepler đề xuất như sau:

(Tới đây cho toàn bộ chủ đề)

chúng ta có thể mượn một ý tưởng từ boost :: iterator_core_access. Tôi đề xuất một lớp học mớistd::shared_ptr_access không có thành viên nào được bảo vệ hoặc công khai và để chỉ định rằng cho std :: make_spl (args ...) và std :: alloc_ Shared (a, args ...), các biểu thức :: new (pv) T (chuyển tiếp (args) ...) và ptr-> ~ T () phải được định dạng tốt trong ngữ cảnh của std :: shared_ptr_access.

Việc triển khai std :: shared_ptr_access có thể giống như:

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

Sử dụng

Nếu / khi những điều trên được thêm vào tiêu chuẩn, chúng ta chỉ cần làm:

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

Nếu điều này cũng có vẻ như là một bổ sung quan trọng cho tiêu chuẩn đối với bạn, vui lòng thêm 2 xu của bạn vào Nhóm Google isocpp được liên kết.

Tôi nhận ra chủ đề này khá cũ, nhưng tôi đã tìm thấy một câu trả lời không yêu cầu sự kế thừa hoặc các đối số bổ sung cho hàm tạo mà tôi không thể thấy ở nơi nào khác. Nó không phải là di động mặc dù:

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

Tôi đã thử nghiệm trên windows và linux, nó có thể cần tinh chỉnh cho các nền tảng khác nhau.

Có một vấn đề thú vị hơn và thú vị hơn xảy ra khi bạn có hai lớp A và B liên quan chặt chẽ với nhau.

Nói A là "lớp chủ" và B là "nô lệ" của nó. Nếu bạn muốn hạn chế khởi tạo B chỉ với A, bạn sẽ đặt công cụ xây dựng của B ở chế độ riêng tư và bạn B thành A như thế này

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

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

Thật không may, gọi std::make_shared<B>()từ một phương thức Asẽ làm cho trình biên dịch phàn nàn về B::B()việc riêng tư.

Giải pháp của tôi cho vấn đề này là tạo một Passlớp giả công khai (giống như nullptr_t) bên trong Bcó hàm tạo riêng và là bạn với Avà làm cho hàm tạo Bcủa công khai và thêm Passvào các đối số của nó, như thế này.

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

Nếu bạn cũng muốn kích hoạt một bộ dẫn có các đối số, điều này có thể giúp một chút.

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

[Chỉnh sửa] Tôi đọc qua các chủ đề được ghi chú ở trên về một std::shared_ptr_access<>đề xuất được tiêu chuẩn hóa . Trong đó có một phản hồi lưu ý một bản sửa lỗi std::allocate_shared<>và một ví dụ về việc sử dụng nó. Tôi đã điều chỉnh nó theo mẫu nhà máy bên dưới và đã thử nghiệm nó theo gcc C ++ 11/14/17. Nó cũng hoạt động với std::enable_shared_from_this<>, vì vậy rõ ràng sẽ thích hợp hơn với giải pháp ban đầu của tôi trong câu trả lời này. Đây là ...

#include <iostream>
#include <memory>

class Factory final {
public:
    template<typename T, typename... A>
    static std::shared_ptr<T> make_shared(A&&... args) {
        return std::allocate_shared<T>(Alloc<T>(), std::forward<A>(args)...);
    }
private:
    template<typename T>
    struct Alloc : std::allocator<T> {
        template<typename U, typename... A>
        void construct(U* ptr, A&&... args) {
            new(ptr) U(std::forward<A>(args)...);
        }
        template<typename U>
        void destroy(U* ptr) {
            ptr->~U();
        }
    };  
};

class X final : public std::enable_shared_from_this<X> {
    friend class Factory;
private:
    X()      { std::cout << "X() addr=" << this << "\n"; }
    X(int i) { std::cout << "X(int) addr=" << this << " i=" << i << "\n"; }
    ~X()     { std::cout << "~X()\n"; }
};

int main() {
    auto p1 = Factory::make_shared<X>(42);
    auto p2 = p1->shared_from_this();
    std::cout << "p1=" << p1 << "\n"
              << "p2=" << p2 << "\n"
              << "count=" << p1.use_count() << "\n";
}

[Orig] Tôi tìm thấy một giải pháp bằng cách sử dụng hàm tạo bí danh con trỏ chia sẻ. Nó cho phép cả ctor và dtor ở chế độ riêng tư, cũng như sử dụng bộ xác định cuối cùng.

#include <iostream>
#include <memory>

class Factory final {
public:
    template<typename T, typename... A>
    static std::shared_ptr<T> make_shared(A&&... args) {
        auto ptr = std::make_shared<Type<T>>(std::forward<A>(args)...);
        return std::shared_ptr<T>(ptr, &ptr->type);
    }
private:
    template<typename T>
    struct Type final {
        template<typename... A>
        Type(A&&... args) : type(std::forward<A>(args)...) { std::cout << "Type(...) addr=" << this << "\n"; }
        ~Type() { std::cout << "~Type()\n"; }
        T type;
    };
};

class X final {
    friend struct Factory::Type<X>;  // factory access
private:
    X()      { std::cout << "X() addr=" << this << "\n"; }
    X(int i) { std::cout << "X(...) addr=" << this << " i=" << i << "\n"; }
    ~X()     { std::cout << "~X()\n"; }
};

int main() {
    auto ptr1 = Factory::make_shared<X>();
    auto ptr2 = Factory::make_shared<X>(42);
}

Lưu ý rằng cách tiếp cận ở trên không phù hợp với std::enable_shared_from_this<>vì ban đầu std::shared_ptr<>là về trình bao bọc chứ không phải kiểu chính nó. Chúng tôi có thể giải quyết vấn đề này với một lớp tương đương tương thích với nhà máy ...

#include <iostream>
#include <memory>

template<typename T>
class EnableShared {
    friend class Factory;  // factory access
public:
    std::shared_ptr<T> shared_from_this() { return weak.lock(); }
protected:
    EnableShared() = default;
    virtual ~EnableShared() = default;
    EnableShared<T>& operator=(const EnableShared<T>&) { return *this; }  // no slicing
private:
    std::weak_ptr<T> weak;
};

class Factory final {
public:
    template<typename T, typename... A>
    static std::shared_ptr<T> make_shared(A&&... args) {
        auto ptr = std::make_shared<Type<T>>(std::forward<A>(args)...);
        auto alt = std::shared_ptr<T>(ptr, &ptr->type);
        assign(std::is_base_of<EnableShared<T>, T>(), alt);
        return alt;
    }
private:
    template<typename T>
    struct Type final {
        template<typename... A>
        Type(A&&... args) : type(std::forward<A>(args)...) { std::cout << "Type(...) addr=" << this << "\n"; }
        ~Type() { std::cout << "~Type()\n"; }
        T type;
    };
    template<typename T>
    static void assign(std::true_type, const std::shared_ptr<T>& ptr) {
        ptr->weak = ptr;
    }
    template<typename T>
    static void assign(std::false_type, const std::shared_ptr<T>&) {}
};

class X final : public EnableShared<X> {
    friend struct Factory::Type<X>;  // factory access
private:
    X()      { std::cout << "X() addr=" << this << "\n"; }
    X(int i) { std::cout << "X(...) addr=" << this << " i=" << i << "\n"; }
    ~X()     { std::cout << "~X()\n"; }
};

int main() {
    auto ptr1 = Factory::make_shared<X>();
    auto ptr2 = ptr1->shared_from_this();
    std::cout << "ptr1=" << ptr1.get() << "\nptr2=" << ptr2.get() << "\n";
}

Cuối cùng, ai đó nói clang phàn nàn về Factory :: Loại là riêng tư khi được sử dụng như một người bạn, vì vậy hãy công khai nếu đó là trường hợp. Phơi bày nó không có hại.

Tôi đã có cùng một vấn đề, nhưng không có câu trả lời nào hiện có thực sự thỏa đáng vì tôi cần chuyển các đối số cho hàm tạo được bảo vệ. Hơn nữa, tôi cần phải làm điều này cho một số lớp, mỗi lớp lấy các đối số khác nhau.

Để đạt được hiệu quả đó và dựa trên một số câu trả lời hiện có mà tất cả đều sử dụng các phương pháp tương tự, tôi trình bày cái nugget nhỏ này:

template < typename Object, typename... Args >
inline std::shared_ptr< Object >
protected_make_shared( Args&&... args )
{
  struct helper : public Object
  {
    helper( Args&&... args )
      : Object{ std::forward< Args >( args )... }
    {}
  };

  return std::make_shared< helper >( std::forward< Args >( args )... );
}

Nguyên nhân của vấn đề là nếu hàm hoặc lớp mà bạn của bạn thực hiện các cuộc gọi cấp thấp hơn đến hàm tạo của bạn, thì chúng cũng phải được kết bạn. std :: make_ Shared không phải là chức năng thực sự gọi hàm tạo của bạn để kết bạn với nó không có gì khác biệt.

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 thực sự đang gọi nhà xây dựng của bạn, vì vậy nó cần phải là một người bạn. Vì đó là một chút tối nghĩa, tôi sử dụng một 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;

Sau đó, khai báo lớp của bạn trông khá đơn giản. Bạn có thể tạo một macro duy nhất để khai báo ptr và lớp nếu bạn thích.

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

Đây thực sự là một vấn đề quan trọng. Để làm cho mã duy trì, di động, bạn cần ẩn càng nhiều việc thực hiện càng tốt.

typedef std::shared_ptr<A> APtr;

ẩn cách bạn xử lý con trỏ thông minh của mình một chút, bạn phải chắc chắn sử dụng typedef của mình. Nhưng nếu bạn luôn phải tạo một cái bằng cách sử dụng make_ Shared, nó sẽ đánh bại mục đích.

Ví dụ trên buộc mã sử dụng lớp của bạn sử dụng hàm tạo con trỏ thông minh của bạn, điều đó có nghĩa là nếu bạn chuyển sang một hương vị mới của con trỏ thông minh, bạn thay đổi khai báo lớp và bạn có cơ hội hoàn thành tốt. KHÔNG cho rằng ông chủ hoặc dự án tiếp theo của bạn sẽ sử dụng kế hoạch stl, boost, vv để thay đổi nó một ngày nào đó.

Làm điều này trong gần 30 năm, tôi đã phải trả giá đắt về thời gian, nỗi đau và tác dụng phụ để sửa chữa điều này khi nó được thực hiện sai cách đây nhiều năm.

Bạn có thể sử dụng điều này:

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