C ++ Singleton design pattern

Baru-baru ini saya bertemu dengan realisasi / implementasi pola desain Singleton untuk C ++. Itu terlihat seperti ini (saya telah mengadopsi dari contoh kehidupan nyata):

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

Dari deklarasi ini saya dapat menyimpulkan bahwa bidang instance diinisiasi di heap. Itu berarti ada alokasi memori. Apa yang benar-benar tidak jelas bagi saya adalah kapan tepatnya memori itu akan dialokasikan? Atau ada kebocoran bug dan memori? Sepertinya ada masalah dalam implementasinya.

Pertanyaan utama saya adalah, bagaimana cara menerapkannya dengan cara yang benar?

Pada tahun 2008 saya memberikan implementasi C ++ 98 dari pola desain Singleton yang dievaluasi malas, dijamin kehancuran, tidak aman secara teknis:
Bisakah ada yang memberi saya sampel Singleton di c ++?

Berikut ini adalah implementasi C ++ 11 yang diperbarui dari pola desain Singleton yang dievaluasi dengan malas, dihancurkan dengan benar, dan aman dari benang .

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

Lihat artikel ini tentang kapan menggunakan singleton: (tidak sering)
Singleton: Bagaimana seharusnya digunakan

Lihat dua artikel ini tentang urutan inisialisasi dan cara mengatasinya:
Urutan inisialisasi variabel statis
Menemukan masalah C + + inisialisasi statis

Lihat artikel ini yang menggambarkan masa hidup:
Apa masa pakai variabel statis dalam fungsi C ++?

Lihat artikel ini yang membahas beberapa implikasi threading untuk lajang:
Contoh Singleton dideklarasikan sebagai variabel statis metode GetInstance, apakah ini aman untuk thread?

Lihat artikel ini yang menjelaskan mengapa penguncian ganda tidak akan bekerja pada C ++:
Apa saja perilaku tak terdefinisi umum yang harus diketahui oleh seorang programmer C ++?
Dr Dobbs: C ++ dan The Perils of Double-Checked Locking: Bagian I

Menjadi seorang Singleton, Anda biasanya tidak ingin itu dihancurkan.

Ini akan dirobohkan dan didelokasi ketika program berakhir, yang merupakan perilaku normal yang diinginkan untuk seorang lajang. Jika Anda ingin dapat membersihkannya secara eksplisit, cukup mudah untuk menambahkan metode statis ke kelas yang memungkinkan Anda untuk mengembalikannya ke kondisi bersih, dan mengalokasikannya kembali saat digunakan, tetapi itu di luar ruang lingkup suatu singleton "klasik".

Anda dapat menghindari alokasi memori. Ada banyak varian, semuanya memiliki masalah dalam hal lingkungan multithreading.

Saya lebih suka implementasi semacam ini (sebenarnya, tidak benar mengatakan saya lebih suka, karena saya menghindari lajang sebanyak mungkin):

class Singleton
{
private:
   Singleton();

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

Tidak memiliki alokasi memori dinamis.

Jawaban @Loki Astari luar biasa.

Namun ada kalanya dengan beberapa objek statis di mana Anda harus dapat menjamin bahwa singleton tidak akan dihancurkan sampai semua objek statis Anda yang menggunakan singleton tidak lagi membutuhkannya.

Dalam hal ini std::shared_ptrdapat digunakan untuk menjaga singleton tetap hidup untuk semua pengguna bahkan ketika destruktor statis dipanggil di akhir program:

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

Alternatif non-alokasi lain: buat singleton, katakanlah kelas C, sesuai kebutuhan Anda:

singleton<C>()

menggunakan

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

Baik ini maupun jawaban Cătălin secara otomatis aman di C ++ saat ini, tetapi akan berada di C ++ 0x.

Saya tidak menemukan implementasi CRTP di antara jawaban, jadi ini dia:

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

Untuk menggunakan cukup mewarisi kelas Anda dari ini, seperti: class Test : public Singleton<Test>

Solusi dalam jawaban yang diterima memiliki kelemahan yang signifikan - destruktor untuk singleton dipanggil setelah kontrol meninggalkan main()fungsi. Mungkin ada masalah sebenarnya, ketika beberapa objek dependen dialokasikan di dalamnyamain .

Saya menemui masalah ini, ketika mencoba memperkenalkan Singleton di aplikasi Qt. Saya memutuskan, bahwa semua dialog pengaturan saya harus berupa Singletons, dan mengadopsi pola di atas. Sayangnya, kelas utama Qt QApplicationdialokasikan pada stack di Internetmain fungsi, dan Qt melarang membuat / menghancurkan dialog ketika tidak ada objek aplikasi yang tersedia.

Itulah sebabnya saya lebih suka lajang yang dialokasikan untuk tumpukan. Saya memberikan metode init()dan eksplisit term()untuk semua lajang dan memanggil mereka di dalam main. Jadi saya memiliki kontrol penuh atas urutan penciptaan / penghancuran lajang, dan saya juga menjamin bahwa lajang akan dibuat, tidak peduli apakah seseorang memanggil getInstance()atau tidak.

Berikut ini adalah implementasi yang mudah.

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

Hanya satu objek yang dibuat dan referensi objek ini dikembalikan setiap dan sesudahnya.

SingletonClass instance created!
00915CB8
00915CB8

Di sini 00915CB8 adalah lokasi memori Object singleton, sama untuk durasi program tetapi (biasanya!) Berbeda setiap kali program dijalankan.

NB Ini bukan thread yang aman. Anda harus memastikan keamanan thread.

Jika Anda ingin mengalokasikan objek di tumpukan, mengapa tidak menggunakan pointer unik. Memori juga akan dibatalkan alokasi karena kita menggunakan pointer unik.

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

Memang mungkin dialokasikan dari tumpukan, tetapi tanpa sumber tidak ada cara untuk mengetahui.

Implementasi tipikal (diambil dari beberapa kode yang saya miliki di emacs) adalah:

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

... dan andalkan program keluar dari ruang lingkup untuk membersihkan sesudahnya.

Jika Anda bekerja pada platform di mana pembersihan harus dilakukan secara manual, saya mungkin akan menambahkan rutin pembersihan manual.

Masalah lain dengan melakukannya dengan cara ini adalah tidak aman-utas. Dalam lingkungan multithreaded, dua utas bisa melewati "jika" sebelum keduanya memiliki kesempatan untuk mengalokasikan contoh baru (jadi keduanya akan). Ini masih bukan masalah besar jika Anda mengandalkan penghentian program untuk membersihkan.

Adakah yang menyebutkan std::call_oncedan std::once_flag? Sebagian besar pendekatan lain - termasuk penguncian ganda diperiksa - rusak.

Salah satu masalah utama dalam penerapan pola tunggal adalah inisialisasi yang aman. Satu-satunya cara yang aman adalah untuk menjaga urutan inisialisasi dengan hambatan sinkronisasi. Tetapi hambatan itu sendiri harus dimulai dengan aman. std::once_flagadalah mekanisme untuk mendapatkan inisialisasi aman yang dijamin.

Kami membahas topik ini baru-baru ini di kelas EECS saya. Jika Anda ingin melihat catatan kuliah secara detail, kunjungi http://umich.edu/~eecs381/lecture/IdiomsDesPattsCreational.pdf

Ada dua cara yang saya tahu untuk membuat kelas Singleton dengan benar.

Cara pertama:

Terapkan itu mirip dengan cara Anda memilikinya dalam contoh Anda. Sedangkan untuk penghancuran, "Lajang biasanya bertahan lama selama program dijalankan; sebagian besar OS akan memulihkan memori dan sebagian besar sumber daya lainnya ketika sebuah program berakhir, sehingga ada argumen untuk tidak khawatir tentang hal ini."

Namun, adalah praktik yang baik untuk membersihkan pada penghentian program. Oleh karena itu, Anda dapat melakukan ini dengan kelas SingletonDestructor statis tambahan dan menyatakannya sebagai teman di Singleton Anda.

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 akan dibuat pada startup program, dan "ketika program berakhir, semua objek global / statis dihancurkan oleh kode shutdown perpustakaan runtime (dimasukkan oleh linker), sehingga the_destroyer akan dihancurkan; destructor-nya akan menghapus Singleton, menjalankan destruktor. "

Jalan Kedua

Ini disebut Singleton Meyers, dibuat oleh penyihir C ++ Scott Meyers. Cukup tentukan get_instance () secara berbeda. Sekarang Anda juga dapat menyingkirkan variabel anggota penunjuk.

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

Ini rapi karena nilai yang dikembalikan adalah dengan referensi dan Anda dapat menggunakan .sintaks alih-alih ->mengakses variabel anggota.

"Kompiler secara otomatis membuat kode yang menciptakan 's' pertama kali melalui deklarasi, tidak setelahnya, dan kemudian menghapus objek statis pada penghentian program."

Perhatikan juga bahwa dengan Meyers Singleton Anda "dapat masuk ke situasi yang sangat sulit jika objek saling bergantung pada saat penghentian - kapan Singleton menghilang relatif terhadap objek lain? Tetapi untuk aplikasi sederhana, ini berfungsi dengan baik."

Selain diskusi lain di sini, mungkin perlu dicatat bahwa Anda dapat memiliki ke-global-an, tanpa membatasi penggunaan pada satu contoh. Sebagai contoh, pertimbangkan kasus referensi menghitung sesuatu ...

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

Sekarang di suatu tempat di dalam suatu fungsi (seperti main) yang dapat Anda lakukan:

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

Wasit tidak perlu menyimpan pointer kembali ke masing-masing Storekarena informasi tersebut diberikan pada waktu kompilasi. Anda juga tidak perlu khawatir tentang masa Storepakai karena kompiler mengharuskan itu bersifat global. Jika memang hanya ada satu contoh Storemaka tidak ada overhead dalam pendekatan ini; dengan lebih dari satu contoh terserah kompiler untuk menjadi pintar tentang pembuatan kode. Jika perlu, ItemRefkelas bahkan dapat membuat frienddariStore (Anda dapat memiliki teman templated!).

Jika Storeitu sendiri adalah kelas templated maka hal-hal menjadi berantakan, tetapi masih mungkin untuk menggunakan metode ini, mungkin dengan menerapkan kelas pembantu dengan tanda tangan berikut:

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>. */ };

Pengguna sekarang dapat membuat StoreWrapperjenis (dan instance global) untuk setiap Storeinstance global , dan selalu mengakses toko melalui instance wrapper mereka (dengan demikian melupakan detail berdarah parameter templat yang diperlukan untuk menggunakan Store).

Ini tentang manajemen objek seumur hidup. Misalkan Anda memiliki lebih dari lajang dalam perangkat lunak Anda. Dan mereka bergantung pada Logger singleton. Selama penghancuran aplikasi, misalkan objek singleton lain menggunakan Logger untuk mencatat langkah-langkah penghancurannya. Anda harus menjamin bahwa Logger harus dibersihkan terakhir. Oleh karena itu, harap periksa juga makalah ini: http://www.cs.wustl.edu/~schmidt/PDF/ObjMan.pdf

Implementasi saya mirip dengan Galik. Perbedaannya adalah implementasi saya memungkinkan pointer bersama untuk membersihkan memori yang dialokasikan, sebagai kebalikan dari memegang memori hingga aplikasi keluar dan pointer statis dibersihkan.

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

Kode Anda benar, kecuali bahwa Anda tidak mendeklarasikan pointer instance di luar kelas . Deklarasi kelas statis variabel statis tidak dianggap deklarasi dalam C ++, namun ini diizinkan dalam bahasa lain seperti C # atau Java dll.

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

Anda harus tahu bahwa instance Singleton tidak perlu dihapus secara manual oleh kami . Kita memerlukan satu objek dari itu di seluruh program, jadi pada akhir pelaksanaan program, itu akan secara otomatis dialokasikan.

Makalah yang dikaitkan dengan di atas menjelaskan kekurangan dari penguncian diperiksa ganda adalah bahwa kompiler dapat mengalokasikan memori untuk objek dan mengatur pointer ke alamat memori yang dialokasikan, sebelum konstruktor objek telah dipanggil. Namun sangat mudah dalam c ++ untuk menggunakan pengalokasi untuk mengalokasikan memori secara manual, dan kemudian menggunakan panggilan konstruk untuk menginisialisasi memori. Menggunakan appraoch ini, penguncian diperiksa dua kali berfungsi dengan baik.

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

Contoh:

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

    public:
        INS(CCtrl);

Kelas singleton sederhana, Ini harus menjadi file kelas tajuk Anda

#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

Akses singleton Anda seperti ini:

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

Saya pikir Anda harus menulis fungsi statis di mana objek statis Anda dihapus. Anda harus memanggil fungsi ini ketika Anda akan menutup aplikasi Anda. Ini akan memastikan Anda tidak mengalami kebocoran memori.