Mẫu thiết kế Singleton C ++

Gần đây, tôi đã tình cờ nhận ra / triển khai mẫu thiết kế Singleton cho C ++. Nó trông giống như thế này (tôi đã áp dụng nó từ ví dụ thực tế):

// a lot of methods are omitted here
class Singleton
{
   public:
       static Singleton* getInstance( );
       ~Singleton( );
   private:
       Singleton( );
       static Singleton* instance;
};

Từ tuyên bố này, tôi có thể suy ra rằng trường đối tượng được bắt đầu trên heap. Điều đó có nghĩa là có sự phân bổ bộ nhớ. Điều hoàn toàn không rõ ràng đối với tôi là khi chính xác bộ nhớ sẽ bị giải phóng? Hoặc có một lỗi và rò rỉ bộ nhớ? Có vẻ như có một vấn đề trong việc thực hiện.

Câu hỏi chính của tôi là, làm thế nào để tôi thực hiện nó đúng cách?

Vào năm 2008, tôi đã cung cấp một triển khai C ++ 98 cho mẫu thiết kế Singleton được đánh giá lười biếng, phá hủy được bảo đảm, không an toàn về mặt kỹ thuật:
Có ai có thể cung cấp cho tôi một mẫu Singleton trong c ++ không?

Dưới đây là bản triển khai C ++ 11 được cập nhật của mẫu thiết kế Singleton được đánh giá lười biếng, bị phá hủy chính xác và an toàn cho luồng .

class S
{
    public:
        static S& getInstance()
        {
            static S    instance; // Guaranteed to be destroyed.
                                  // Instantiated on first use.
            return instance;
        }
    private:
        S() {}                    // Constructor? (the {} brackets) are needed here.

        // C++ 03
        // ========
        // Don't forget to declare these two. You want to make sure they
        // are unacceptable otherwise you may accidentally get copies of
        // your singleton appearing.
        S(S const&);              // Don't Implement
        void operator=(S const&); // Don't implement

        // C++ 11
        // =======
        // We can use the better technique of deleting the methods
        // we don't want.
    public:
        S(S const&)               = delete;
        void operator=(S const&)  = delete;

        // Note: Scott Meyers mentions in his Effective Modern
        //       C++ book, that deleted functions should generally
        //       be public as it results in better error messages
        //       due to the compilers behavior to check accessibility
        //       before deleted status
};

Xem bài viết này về thời điểm sử dụng singleton: (không thường xuyên)
Singleton: Nên sử dụng nó như thế nào

Xem hai bài viết này về thứ tự khởi tạo và cách đối phó:
Thứ tự khởi tạo biến tĩnh
Tìm kiếm các vấn đề về thứ tự khởi tạo tĩnh C ++

Xem bài viết này mô tả về thời gian sống: Thời
gian tồn tại của biến tĩnh trong hàm C ++ là bao nhiêu?

Xem bài viết này thảo luận về một số hàm ý luồng cho singletons:
Ví dụ Singleton được khai báo là biến tĩnh của phương thức GetInstance, nó có an toàn cho luồng không?

Xem bài viết này giải thích tại sao khóa kiểm tra kép sẽ không hoạt động trên C ++:
Tất cả các hành vi không xác định phổ biến mà lập trình viên C ++ nên biết là gì?
Tiến sĩ Dobbs: C ++ và Những nguy hiểm của việc khóa hai lần: Phần I

Là một người độc thân, bạn thường không muốn nó bị phá hủy.

Nó sẽ bị phá hỏng và bị hủy bỏ khi chương trình kết thúc, đó là hành vi bình thường, mong muốn đối với một người độc thân. Nếu bạn muốn có thể làm sạch nó một cách rõ ràng, thật dễ dàng để thêm một phương thức tĩnh vào lớp cho phép bạn khôi phục nó về trạng thái sạch và để nó được phân bổ lại vào lần tới, nhưng nó nằm ngoài phạm vi của một Singleton "cổ điển".

Bạn có thể tránh phân bổ bộ nhớ. Có nhiều biến thể, tất cả đều có vấn đề trong trường hợp môi trường đa luồng.

Tôi thích loại triển khai này (thực ra, tôi không nói chính xác là tôi thích, vì tôi tránh các singletons càng nhiều càng tốt):

class Singleton
{
private:
   Singleton();

public:
   static Singleton& instance()
   {
      static Singleton INSTANCE;
      return INSTANCE;
   }
};

Nó không có phân bổ bộ nhớ động.

Câu trả lời của @Loki Astari là tuyệt vời.

Tuy nhiên, có những lúc có nhiều đối tượng tĩnh mà bạn cần có thể đảm bảo rằng singleton sẽ không bị hủy cho đến khi tất cả các đối tượng tĩnh sử dụng singleton không còn cần nó nữa.

Trong trường hợp này std::shared_ptr có thể được sử dụng để giữ cho singleton tồn tại cho tất cả người dùng ngay cả khi các hàm hủy tĩnh đang được gọi ở cuối chương trình:

class Singleton
{
public:
    Singleton(Singleton const&) = delete;
    Singleton& operator=(Singleton const&) = delete;

    static std::shared_ptr<Singleton> instance()
    {
        static std::shared_ptr<Singleton> s{new Singleton};
        return s;
    }

private:
    Singleton() {}
};

Một lựa chọn không phân bổ khác: tạo một singleton, nói về lớp C, khi bạn cần:

singleton<C>()

sử dụng

template <class X>
X& singleton()
{
    static X x;
    return x;
}

Cả câu trả lời này và Cătălin đều không tự động an toàn luồng trong C ++ hiện tại, nhưng sẽ ở C ++ 0x.

Tôi không tìm thấy triển khai CRTP trong số các câu trả lời, vì vậy đây là:

template<typename HeirT>
class Singleton
{
public:
    Singleton() = delete;

    Singleton(const Singleton &) = delete;

    Singleton &operator=(const Singleton &) = delete;

    static HeirT &instance()
    {
        static HeirT instance;
        return instance;
    }
};

Để sử dụng chỉ cần kế thừa lớp của bạn từ đây, như: class Test : public Singleton<Test>

Giải pháp trong câu trả lời được chấp nhận có một nhược điểm đáng kể - hàm hủy cho singleton được gọi sau khi điều khiển rời khỏi main()hàm. Có thể có vấn đề thực sự, khi một số đối tượng phụ thuộc được phân bổ bên trongmain .

Tôi đã gặp vấn đề này, khi cố gắng giới thiệu một Singleton trong ứng dụng Qt. Tôi quyết định rằng tất cả các hộp thoại thiết lập của tôi phải là Singletons và chấp nhận mô hình ở trên. Thật không may, lớp chính của Qt QApplicationđã được phân bổ trên stack trong mainhàm và Qt cấm tạo / hủy các hộp thoại khi không có đối tượng ứng dụng nào khả dụng.

Đó là lý do tại sao tôi thích singletons phân bổ heap. Tôi cung cấp một phương thức rõ ràng init()và term()phương thức cho tất cả các singletons và gọi chúng bên trong main. Do đó, tôi có toàn quyền kiểm soát thứ tự tạo / hủy của singletons, và tôi cũng đảm bảo rằng các singletons sẽ được tạo ra, bất kể ai đó có gọi getInstance()hay không.

Đây là một thực hiện dễ dàng.

#include <Windows.h>
#include <iostream>

using namespace std;


class SingletonClass {

public:
    static SingletonClass* getInstance() {

    return (!m_instanceSingleton) ?
        m_instanceSingleton = new SingletonClass : 
        m_instanceSingleton;
    }

private:
    // private constructor and destructor
    SingletonClass() { cout << "SingletonClass instance created!\n"; }
    ~SingletonClass() {}

    // private copy constructor and assignment operator
    SingletonClass(const SingletonClass&);
    SingletonClass& operator=(const SingletonClass&);

    static SingletonClass *m_instanceSingleton;
};

SingletonClass* SingletonClass::m_instanceSingleton = nullptr;



int main(int argc, const char * argv[]) {

    SingletonClass *singleton;
    singleton = singleton->getInstance();
    cout << singleton << endl;

    // Another object gets the reference of the first object!
    SingletonClass *anotherSingleton;
    anotherSingleton = anotherSingleton->getInstance();
    cout << anotherSingleton << endl;

    Sleep(5000);

    return 0;
}

Chỉ có một đối tượng được tạo và tham chiếu đối tượng này được trả về mỗi lần trả lời.

SingletonClass instance created!
00915CB8
00915CB8

Ở đây 00915CB8 là vị trí bộ nhớ của đối tượng singleton, tương tự với thời lượng của chương trình nhưng (thông thường!) Khác nhau mỗi khi chương trình được chạy.

NB Đây không phải là một chủ đề an toàn. Bạn phải đảm bảo an toàn chủ đề.

Nếu bạn muốn phân bổ đối tượng trong heap, tại sao không sử dụng một con trỏ duy nhất. Bộ nhớ cũng sẽ bị giải phóng vì chúng ta đang sử dụng một con trỏ duy nhất.

class S
{
    public:
        static S& getInstance()
        {
            if( m_s.get() == 0 )
            {
              m_s.reset( new S() );
            }
            return *m_s;
        }

    private:
        static std::unique_ptr<S> m_s;

        S();
        S(S const&);            // Don't Implement
        void operator=(S const&); // Don't implement
};

std::unique_ptr<S> S::m_s(0);

Nó thực sự có thể được phân bổ từ đống, nhưng không có các nguồn thì không có cách nào để biết.

Việc triển khai điển hình (lấy từ một số mã tôi đã có trong emacs) sẽ là:

Singleton * Singleton::getInstance() {
    if (!instance) {
        instance = new Singleton();
    };
    return instance;
};

... Và dựa vào chương trình đi ra khỏi phạm vi để dọn dẹp sau đó.

Nếu bạn làm việc trên một nền tảng mà việc dọn dẹp phải được thực hiện thủ công, có lẽ tôi sẽ thêm một thói quen dọn dẹp thủ công.

Một vấn đề khác khi thực hiện theo cách này là nó không an toàn cho chuỗi. Trong một môi trường đa luồng, hai luồng có thể vượt qua "nếu" trước khi có cơ hội phân bổ thể hiện mới (vì vậy cả hai sẽ). Đây vẫn không phải là một thỏa thuận quá lớn nếu bạn đang dựa vào việc chấm dứt chương trình để dọn dẹp.

Có ai đề cập đến std::call_oncevà std::once_flag? Hầu hết các phương pháp khác - bao gồm khóa kiểm tra kép - đều bị hỏng.

Một vấn đề lớn trong việc thực hiện mô hình singleton là khởi tạo an toàn. Cách an toàn duy nhất là bảo vệ chuỗi khởi tạo với các rào cản đồng bộ hóa. Nhưng những rào cản đó cần phải được bắt đầu một cách an toàn. std::once_flaglà cơ chế để được đảm bảo khởi tạo an toàn.

Chúng tôi đã đi qua chủ đề này gần đây trong lớp EECS của tôi. Nếu bạn muốn xem chi tiết các bài giảng, hãy truy cập http://umich.edu/~eecs381/lecture/IdiomsDesPattsCreational.pdf

Có hai cách mà tôi biết để tạo một lớp Singleton chính xác.

Cách thứ nhất:

Thực hiện nó tương tự như cách bạn có nó trong ví dụ của bạn. Về phần hủy diệt, "Singletons thường chịu đựng thời gian chạy chương trình; hầu hết các hệ điều hành sẽ phục hồi bộ nhớ và hầu hết các tài nguyên khác khi chương trình chấm dứt, do đó có một lập luận cho việc không lo lắng về điều này."

Tuy nhiên, đó là một thực hành tốt để làm sạch khi chấm dứt chương trình. Do đó, bạn có thể làm điều này với một lớp SingletonDestructor tĩnh và khai báo đó là một người bạn trong Singleton của bạn.

class Singleton {
public:
  static Singleton* get_instance();

  // disable copy/move -- this is a Singleton
  Singleton(const Singleton&) = delete;
  Singleton(Singleton&&) = delete;
  Singleton& operator=(const Singleton&) = delete;
  Singleton& operator=(Singleton&&) = delete;

  friend class Singleton_destroyer;

private:
  Singleton();  // no one else can create one
  ~Singleton(); // prevent accidental deletion

  static Singleton* ptr;
};

// auxiliary static object for destroying the memory of Singleton
class Singleton_destroyer {
public:
  ~Singleton_destroyer { delete Singleton::ptr; }
};

Singleton_destroyer sẽ được tạo khi khởi động chương trình và "khi chương trình kết thúc, tất cả các đối tượng toàn cầu / tĩnh bị phá hủy bởi mã tắt thư viện thời gian chạy (được chèn bởi trình liên kết), do đó ,_destroyer sẽ bị hủy, trình hủy của nó sẽ xóa Singleton, chạy nó kẻ hủy diệt. "

Cách thứ hai

Đây được gọi là Meyers Singleton, được tạo bởi thuật sĩ C ++ Scott Meyers. Đơn giản chỉ cần định nghĩa get_instance () khác nhau. Bây giờ bạn cũng có thể thoát khỏi biến thành viên con trỏ.

// public member function
static Singleton& Singleton::get_instance()
{
  static Singleton s;
  return s;
}

Điều này là gọn gàng vì giá trị được trả về là do tham chiếu và bạn có thể sử dụng .cú pháp thay vì ->truy cập các biến thành viên.

"Trình biên dịch tự động xây dựng mã tạo lần đầu tiên thông qua khai báo, không phải sau đó và sau đó xóa đối tượng tĩnh khi kết thúc chương trình."

Cũng lưu ý rằng với Meyers Singleton, bạn "có thể gặp tình huống rất khó khăn nếu các đối tượng dựa vào nhau tại thời điểm chấm dứt - khi nào Singleton biến mất so với các đối tượng khác? Nhưng đối với các ứng dụng đơn giản, điều này hoạt động tốt."

Ngoài các cuộc thảo luận khác ở đây, có thể đáng chú ý rằng bạn có thể có tính toàn cầu, mà không giới hạn việc sử dụng trong một trường hợp. Ví dụ, hãy xem xét trường hợp tham chiếu đếm thứ gì đó ...

struct Store{
   std::array<Something, 1024> data;
   size_t get(size_t idx){ /* ... */ }
   void incr_ref(size_t idx){ /* ... */}
   void decr_ref(size_t idx){ /* ... */}
};

template<Store* store_p>
struct ItemRef{
   size_t idx;
   auto get(){ return store_p->get(idx); };
   ItemRef() { store_p->incr_ref(idx); };
   ~ItemRef() { store_p->decr_ref(idx); };
};

Store store1_g;
Store store2_g; // we don't restrict the number of global Store instances

Bây giờ ở đâu đó bên trong một hàm (chẳng hạn như main) bạn có thể làm:

auto ref1_a = ItemRef<&store1_g>(101);
auto ref2_a = ItemRef<&store2_g>(201); 

Các giới thiệu không cần lưu trữ một con trỏ trở lại tương ứng Storevì thông tin đó được cung cấp tại thời điểm biên dịch. Bạn cũng không phải lo lắng về Storethời gian tồn tại vì trình biên dịch yêu cầu nó là toàn cầu. Nếu thực sự chỉ có một ví dụ Storethì không có chi phí nào trong cách tiếp cận này; với nhiều hơn một trường hợp, trình biên dịch sẽ thông minh về việc tạo mã. Nếu cần thiết, các ItemReflớp học thậm chí có thể được thực hiện một friendsố Store(bạn bè bạn có thể đã templated!).

Nếu Storebản thân nó là một lớp templated thì mọi thứ trở nên rắc rối hơn, nhưng vẫn có thể sử dụng phương thức này, có lẽ bằng cách thực hiện một lớp trợ giúp với chữ ký sau:

template <typename Store_t, Store_t* store_p>
struct StoreWrapper{ /* stuff to access store_p, e.g. methods returning 
                       instances of ItemRef<Store_t, store_p>. */ };

Giờ đây, người dùng có thể tạo một StoreWrapperloại (và thể hiện toàn cầu) cho từng Storephiên bản toàn cầu và luôn truy cập vào các cửa hàng thông qua thể hiện trình bao bọc của họ (do đó quên đi các chi tiết chính xác của các tham số mẫu cần sử dụng Store).

Đây là về quản lý cuộc sống đối tượng. Giả sử bạn có nhiều hơn singletons trong phần mềm của bạn. Và họ phụ thuộc vào Logger singleton. Trong quá trình hủy ứng dụng, giả sử một đối tượng singleton khác sử dụng Logger để ghi lại các bước hủy của nó. Bạn phải đảm bảo rằng Logger sẽ được dọn sạch lần cuối. Do đó, vui lòng kiểm tra bài viết này: http://www.cs.wustl.edu/~schmidt/PDF/ObjMan.pdf

Cách thực hiện của tôi tương tự như của Galik. Sự khác biệt là việc triển khai của tôi cho phép các con trỏ chia sẻ dọn sạch bộ nhớ được phân bổ, trái ngược với việc giữ bộ nhớ cho đến khi thoát ứng dụng và các con trỏ tĩnh được dọn sạch.

#pragma once

#include <memory>

template<typename T>
class Singleton
{
private:
  static std::weak_ptr<T> _singleton;
public:
  static std::shared_ptr<T> singleton()
  {
    std::shared_ptr<T> singleton = _singleton.lock();
    if (!singleton) 
    {
      singleton.reset(new T());
      _singleton = singleton;
    }

    return singleton;
  }
};

template<typename T>
std::weak_ptr<T> Singleton<T>::_singleton;

Mã của bạn là chính xác, ngoại trừ việc bạn không khai báo con trỏ cá thể bên ngoài lớp . Các khai báo lớp bên trong của các biến tĩnh không được coi là khai báo trong C ++, tuy nhiên điều này được cho phép trong các ngôn ngữ khác như C # hoặc Java, v.v.

class Singleton
{
   public:
       static Singleton* getInstance( );
   private:
       Singleton( );
       static Singleton* instance;
};
Singleton* Singleton::instance; //we need to declare outside because static variables are global

Bạn phải biết rằng cá thể Singleton không cần phải bị xóa bởi chúng tôi . Chúng ta cần một đối tượng duy nhất của nó trong toàn bộ chương trình, vì vậy khi kết thúc thực hiện chương trình, nó sẽ tự động được giải quyết.

Bài báo được liên kết ở trên mô tả sự thiếu sót của khóa kiểm tra kép là trình biên dịch có thể phân bổ bộ nhớ cho đối tượng và đặt một con trỏ tới địa chỉ của bộ nhớ được phân bổ, trước khi hàm tạo của đối tượng được gọi. Tuy nhiên, c ++ khá dễ dàng khi sử dụng bộ cấp phát để cấp phát bộ nhớ theo cách thủ công, sau đó sử dụng lệnh gọi cấu trúc để khởi tạo bộ nhớ. Sử dụng thẩm định này, khóa kiểm tra hai lần hoạt động tốt.

#define INS(c) private:void operator=(c const&){};public:static c& I(){static c _instance;return _instance;}

Thí dụ:

   class CCtrl
    {
    private:
        CCtrl(void);
        virtual ~CCtrl(void);

    public:
        INS(CCtrl);

Lớp đơn giản, Đây phải là tệp lớp tiêu đề của bạn

#ifndef SC_SINGLETON_CLASS_H
#define SC_SINGLETON_CLASS_H

class SingletonClass
{
    public:
        static SingletonClass* Instance()
        {
           static SingletonClass* instance = new SingletonClass();
           return instance;
        }

        void Relocate(int X, int Y, int Z);

    private:
        SingletonClass();
        ~SingletonClass();
};

#define sSingletonClass SingletonClass::Instance()

#endif

Truy cập singleton của bạn như thế này:

sSingletonClass->Relocate(1, 2, 5);

Tôi nghĩ Bạn nên viết một hàm tĩnh trong đó đối tượng tĩnh của bạn bị xóa. Bạn nên gọi chức năng này khi bạn sắp đóng ứng dụng của mình. Điều này sẽ đảm bảo bạn không bị rò rỉ bộ nhớ.