รูปแบบการออกแบบ C ++ Singleton

เมื่อเร็ว ๆ นี้ฉันได้พบกับการตระหนักถึง / การใช้รูปแบบการออกแบบซิงเกิลตันสำหรับ C ++ มันมีลักษณะเช่นนี้ (ฉันยอมรับมันจากตัวอย่างในชีวิตจริง):

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

จากการประกาศนี้ฉันสามารถอนุมานได้ว่ามีการเริ่มต้นฟิลด์อินสแตนซ์บนฮีป นั่นหมายความว่ามีการจัดสรรหน่วยความจำ สิ่งที่ไม่ชัดเจนสำหรับฉันคือเมื่อหน่วยความจำจะถูกจัดสรรคืนหรือไม่ หรือมีข้อบกพร่องและหน่วยความจำรั่ว? ดูเหมือนว่ามีปัญหาในการใช้งาน

คำถามหลักของฉันคือฉันจะใช้มันอย่างถูกวิธีได้อย่างไร

ในปี 2008 ฉันให้การใช้งาน C ++ 98 ของรูปแบบการออกแบบซิงเกิลตันที่ได้รับการประเมินอย่างเชื่องช้ารับประกันการทำลายล้างไม่ใช่เทคนิคที่ปลอดภัยสำหรับเธรด: ผู้
ใดสามารถส่งตัวอย่างของซิงเกิลตันใน c ++ ได้หรือไม่

นี่คือการปรับปรุง C ++ 11 การดำเนินการตามรูปแบบการออกแบบโทนที่เป็นคนขี้เกียจ-ประเมินอย่างถูกต้องถูกทำลายและด้ายปลอดภัย

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

ดูบทความนี้เกี่ยวกับเวลาที่จะใช้ซิงเกิล: (ไม่บ่อย)
Singleton: ควรใช้อย่างไร

ดูบทความทั้งสองนี้เกี่ยวกับลำดับการเริ่มต้นและวิธีรับมือ:
ตัวแปรแบบคงที่การเริ่มต้นคำสั่งการ
ค้นหาปัญหาการเริ่มต้นแบบคงที่ C ++

ดูบทความนี้อธิบายอายุการใช้งาน:
อะไรคืออายุการใช้งานของตัวแปรแบบคงที่ในฟังก์ชัน C ++?

ดูบทความนี้ที่กล่าวถึงผลกระทบของการเธรดบางอย่างกับ singletons:
อินสแตนซ์ Singleton ที่ประกาศเป็นตัวแปรแบบคงที่ของวิธี GetInstance มันเป็นเธรดที่ปลอดภัยหรือไม่

ดูบทความนี้ที่อธิบายว่าทำไมการล็อกที่ถูกตรวจสอบซ้ำสองครั้งจะไม่ทำงานใน C ++:
พฤติกรรมที่ไม่ได้กำหนดทั่วไปที่โปรแกรมเมอร์ C ++ ควรรู้คืออะไร?
ดร. ดอบส์: C ++ และภัยคุกคามของการล็อคเช็คที่สอง: ตอนที่ 1

การเป็นซิงเกิลคุณมักไม่ต้องการให้ถูกทำลาย

มันจะถูกดึงลงและยกเลิกการจัดสรรเมื่อโปรแกรมสิ้นสุดซึ่งเป็นพฤติกรรมปกติที่ต้องการสำหรับซิงเกิล หากคุณต้องการทำความสะอาดอย่างชัดเจนเป็นเรื่องง่ายที่จะเพิ่มวิธีการแบบคงที่ให้กับคลาสที่อนุญาตให้คุณกู้คืนเป็นสถานะที่สะอาดและให้ทำการจัดสรรใหม่ในครั้งถัดไปที่ใช้ แต่นั่นอยู่นอกขอบเขตของ ซิงเกิล "คลาสสิค"

คุณสามารถหลีกเลี่ยงการจัดสรรหน่วยความจำ มีตัวแปรหลายตัวทุกตัวมีปัญหาในกรณีที่มีสภาพแวดล้อมแบบมัลติเธรด

ฉันชอบการนำไปใช้แบบนี้ (จริง ๆ แล้วมันไม่ถูกต้องว่าฉันชอบเพราะฉันหลีกเลี่ยงซิงเกิลมากที่สุด):

class Singleton
{
private:
   Singleton();

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

ไม่มีการจัดสรรหน่วยความจำแบบไดนามิก

คำตอบของ @Loki Astariนั้นยอดเยี่ยม

อย่างไรก็ตามมีหลายครั้งที่มีวัตถุสแตติกหลายตัวที่คุณต้องสามารถรับประกันได้ว่าซิงเกิลตันจะไม่ถูกทำลายจนกว่าวัตถุสแตติกทั้งหมดของคุณที่ใช้ซิงเกิลไม่จำเป็นต้องใช้อีกต่อไป

ในกรณีนี้std::shared_ptrสามารถใช้เพื่อรักษาซิงเกิลตันให้กับผู้ใช้ทุกคนแม้ในขณะที่มีการเรียก destructors แบบคงที่ในตอนท้ายของโปรแกรม:

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

ทางเลือกอื่นที่ไม่จัดสรร: สร้างซิงเกิลตันของคลาสCตามที่คุณต้องการ:

singleton<C>()

การใช้

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

ทั้งคำตอบนี้และคำตอบของCătălinนั้นปลอดภัยสำหรับเธรดโดยอัตโนมัติใน C ++ ปัจจุบัน แต่จะอยู่ใน C ++ 0x

ฉันไม่พบการติดตั้ง CRTP ในคำตอบดังนั้นนี่คือ:

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

หากต้องการใช้เพียงแค่สืบทอดคลาสของคุณจากสิ่งนี้เช่น: class Test : public Singleton<Test>

วิธีแก้ปัญหาในคำตอบที่ยอมรับนั้นมีข้อเสียเปรียบที่สำคัญคือ destructor สำหรับ singleton ถูกเรียกหลังจากการควบคุมออกจากmain()ฟังก์ชัน mainอาจจะมีปัญหาจริงๆเมื่อบางวัตถุขึ้นอยู่ภายในได้รับการจัดสรร

ฉันพบปัญหานี้เมื่อพยายามที่จะแนะนำ Singleton ในแอปพลิเคชัน Qt ฉันตัดสินใจว่ากล่องโต้ตอบการตั้งค่าทั้งหมดของฉันต้องเป็นซิงเกิลตันและใช้รูปแบบข้างต้น น่าเสียดายที่คลาสหลักของ Qt QApplicationได้รับการจัดสรรบนสแต็กในmainฟังก์ชั่นและห้ามการสร้าง / ทำลายกล่องโต้ตอบเมื่อไม่มีวัตถุแอปพลิเคชัน

นั่นคือเหตุผลที่ฉันชอบซิงเกิล - ฮีปที่ได้รับการจัดสรร ผมให้ชัดเจนinit()และterm()วิธีการสำหรับการ singletons mainทั้งหมดและเรียกพวกเขาภายใน ดังนั้นฉันจึงสามารถควบคุมลำดับการสร้าง / การทำลายเดี่ยวและฉันรับประกันได้ว่าจะสร้างซิงเกิลไม่ว่าจะมีใครโทรมาgetInstance()หรือไม่ก็ตาม

นี่คือการใช้งานที่ง่าย

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

มีเพียงวัตถุเดียวที่สร้างขึ้นและการอ้างอิงวัตถุนี้จะถูกส่งคืนในภายหลังทุกครั้ง

SingletonClass instance created!
00915CB8
00915CB8

ที่นี่ 00915CB8 เป็นตำแหน่งหน่วยความจำของ Singleton Object เหมือนกันกับช่วงเวลาของโปรแกรม แต่ (ปกติ!) จะแตกต่างกันในแต่ละครั้งที่โปรแกรมทำงาน

NB นี้ไม่ได้เป็นหัวข้อที่ปลอดภัยคุณต้องให้แน่ใจว่าหัวข้อความปลอดภัย

หากคุณต้องการจัดสรรวัตถุในกองทำไมไม่ใช้ตัวชี้ที่ไม่ซ้ำกัน หน่วยความจำจะถูกยกเลิกการจัดสรรเนื่องจากเราใช้ตัวชี้เฉพาะ

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

แน่นอนมันอาจถูกจัดสรรจากกอง แต่ไม่มีแหล่งที่มาไม่มีทางรู้

การใช้งานทั่วไป (นำมาจากรหัสบางอย่างที่ฉันมีใน emacs แล้ว) จะเป็น:

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

... และพึ่งพาโปรแกรมที่ออกนอกขอบเขตเพื่อทำความสะอาดในภายหลัง

หากคุณทำงานบนแพลตฟอร์มที่ต้องทำการล้างข้อมูลด้วยตนเองฉันอาจเพิ่มขั้นตอนการล้างข้อมูลด้วยตนเอง

ปัญหาอีกประการของการทำเช่นนี้คือมันไม่ปลอดภัยสำหรับเธรด ในสภาพแวดล้อมแบบมัลติเธรดเธรดสองเธรดสามารถผ่าน "ถ้า" ก่อนที่จะมีโอกาสในการจัดสรรอินสแตนซ์ใหม่ นี่ยังไม่ใหญ่เกินไปถ้าคุณวางใจในการยกเลิกโปรแกรมเพื่อล้างข้อมูล

มีใครพูดถึงstd::call_onceและstd::once_flag? วิธีการอื่น ๆ ส่วนใหญ่ - รวมถึงการตรวจสอบการล็อคซ้ำ - หัก

ปัญหาสำคัญอย่างหนึ่งในการใช้รูปแบบซิงเกิลคือการเริ่มต้นอย่างปลอดภัย วิธีเดียวที่ปลอดภัยคือการป้องกันลำดับการเริ่มต้นด้วยการซิงโครไนซ์อุปสรรค แต่อุปสรรคเหล่านั้นเองก็ต้องเริ่มต้นอย่างปลอดภัย std::once_flagเป็นกลไกในการรับประกันการเริ่มต้นอย่างปลอดภัย

เราไปที่หัวข้อนี้เมื่อไม่นานมานี้ในชั้นเรียน EECS ของฉัน หากคุณต้องการดูรายละเอียดของเอกสารประกอบการบรรยายโปรดไปที่http://umich.edu/~eecs381/lecture/IdiomsDesPattsCresh.pdf

มีสองวิธีที่ฉันรู้ในการสร้างคลาส Singleton อย่างถูกต้อง

วิธีแรก:

ใช้มันคล้ายกับที่คุณมีในตัวอย่าง สำหรับการทำลาย "Singletons มักจะทนต่อความยาวของการเรียกใช้โปรแกรมระบบปฏิบัติการส่วนใหญ่จะกู้คืนหน่วยความจำและทรัพยากรอื่น ๆ ส่วนใหญ่เมื่อโปรแกรมหยุดทำงานดังนั้นจึงมีข้อโต้แย้งว่า

อย่างไรก็ตามเป็นวิธีปฏิบัติที่ดีในการล้างข้อมูลเมื่อสิ้นสุดโปรแกรม ดังนั้นคุณสามารถทำเช่นนี้กับคลาส SingletonDestructor คงที่เสริมและประกาศว่าเป็นเพื่อนใน Singleton ของคุณ

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 จะถูกสร้างขึ้นเมื่อเริ่มต้นโปรแกรมและ "เมื่อโปรแกรมสิ้นสุดลงวัตถุโกลบอล / สแตติกทั้งหมดจะถูกทำลายโดยรหัสปิดไลบรารีของไลบรารีรันไทม์ (แทรกโดยตัวเชื่อมโยง) ดังนั้นตัวทำลายจะถูกทำลายตัวทำลายจะลบ Singleton ออก destructor."

วิธีที่สอง

สิ่งนี้เรียกว่า Meyers Singleton สร้างโดย C ++ wizard Meyers Scott เพียงกำหนด get_instance () ให้แตกต่างกัน ตอนนี้คุณสามารถกำจัดตัวแปรสมาชิกพอยน์เตอร์ได้

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

นี่เป็นระเบียบเพราะค่าที่ส่งคืนเป็นการอ้างอิงและคุณสามารถใช้.ไวยากรณ์แทน->การเข้าถึงตัวแปรสมาชิก

คอมไพเลอร์สร้างรหัสอัตโนมัติที่สร้างครั้งแรกผ่านการประกาศไม่ใช่หลังจากนั้นจากนั้นจึงลบวัตถุแบบสแตติกเมื่อสิ้นสุดโปรแกรม

โปรดทราบว่าด้วย Meyers Singleton คุณ "สามารถเข้าสู่สถานการณ์ที่ยากลำบากมากหากวัตถุพึ่งพาซึ่งกันและกันในเวลาที่สิ้นสุด - Singleton จะหายไปเมื่อเทียบกับวัตถุอื่น ๆ หรือไม่ แต่สำหรับแอปพลิเคชันที่เรียบง่าย

นอกเหนือจากการสนทนาอื่น ๆ ที่นี่อาจเป็นเรื่องน่าสังเกตว่าคุณสามารถมีความเป็นสากลได้โดยไม่ จำกัด การใช้งานเพียงครั้งเดียว ตัวอย่างเช่นพิจารณากรณีของการอ้างอิงการนับบางสิ่ง ...

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

ตอนนี้ภายในฟังก์ชัน (เช่นmain) คุณสามารถทำได้:

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

ผู้อ้างอิงไม่จำเป็นต้องเก็บตัวชี้กลับไปStoreที่รายการนั้นเพราะข้อมูลนั้นจะถูกส่งมาในเวลารวบรวม คุณไม่ต้องกังวลเกี่ยวกับStoreอายุการใช้งานเพราะคอมไพเลอร์ต้องการให้เป็นแบบโกลบอล หากมีเพียงตัวอย่างเดียวจริง ๆStoreแล้วไม่มีค่าใช้จ่ายในวิธีการนี้ ด้วยอินสแตนซ์มากกว่าหนึ่งรายการมันขึ้นอยู่กับคอมไพเลอร์ที่จะฉลาดเกี่ยวกับการสร้างรหัส หากจำเป็นItemRefชั้นเรียนสามารถทำfriendจากStore(คุณสามารถมีเพื่อน templated!)

หากStoreตัวเองเป็นคลาส templated สิ่งต่าง ๆ ก็จะยุ่งเหยิง แต่ก็ยังคงเป็นไปได้ที่จะใช้วิธีนี้บางทีโดยการใช้คลาสตัวช่วยที่มีลายเซ็นต่อไปนี้:

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

ขณะนี้ผู้ใช้สามารถสร้างStoreWrapperประเภท (และอินสแตนซ์ส่วนกลาง) สำหรับแต่ละStoreอินสแตนซ์ส่วนกลางและเข้าถึงร้านค้าผ่านอินสแตนซ์ wrapper ของพวกเขาStoreได้ตลอดเวลา

นี่เป็นเรื่องเกี่ยวกับการจัดการตลอดชีวิตของวัตถุ สมมติว่าคุณมีมากกว่าหนึ่งตันในซอฟต์แวร์ของคุณ และพวกมันก็ขึ้นอยู่กับ Logger singleton ในระหว่างการทำลายแอปพลิเคชันสมมติว่าวัตถุซิงเกิลตันอื่นใช้ Logger เพื่อบันทึกขั้นตอนการทำลาย คุณต้องรับประกันว่า Logger ควรได้รับการทำความสะอาดครั้งสุดท้าย ดังนั้นโปรดตรวจสอบกระดาษนี้: http://www.cs.wustl.edu/~schmidt/PDF/ObjMan.pdf

การใช้งานของฉันคล้ายกับของ Galik ความแตกต่างคือการใช้งานของฉันช่วยให้พอยน์เตอร์ที่ใช้ร่วมกันในการล้างหน่วยความจำที่จัดสรรตรงข้ามกับการเก็บไว้ในหน่วยความจำจนกว่าจะออกจากแอปพลิเคชันและตัวชี้คงที่จะถูกล้าง

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

รหัสของคุณถูกต้องยกเว้นว่าคุณไม่ได้ประกาศตัวชี้อินสแตนซ์นอกชั้นเรียน การประกาศคลาสภายในของตัวแปรสแตติกไม่ถือเป็นการประกาศใน C ++ อย่างไรก็ตามสิ่งนี้ได้รับอนุญาตในภาษาอื่นเช่นC #หรือJavaเป็นต้น

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

คุณต้องรู้ว่าอินสแตนซ์ซิงเกิลไม่จำเป็นต้องถูกลบออกด้วยตนเองโดยเรา เราต้องการวัตถุเดียวของมันตลอดทั้งโปรแกรมดังนั้นเมื่อสิ้นสุดการทำงานของโปรแกรมมันจะถูกยกเลิกการจัดสรรโดยอัตโนมัติ

กระดาษที่เชื่อมโยงกับข้างต้นอธิบายถึงข้อบกพร่องของการล็อคการตรวจสอบสองครั้งคือคอมไพเลอร์อาจจัดสรรหน่วยความจำสำหรับวัตถุและตั้งค่าตัวชี้ไปยังที่อยู่ของหน่วยความจำที่จัดสรรก่อนที่จะเรียกตัวสร้างวัตถุ มันค่อนข้างง่ายใน c ++ อย่างไรก็ตามการใช้ allocaters เพื่อจัดสรรหน่วยความจำด้วยตนเองแล้วใช้การเรียกใช้โครงสร้างเพื่อเริ่มต้นหน่วยความจำ การใช้การประเมินค่านี้การล็อคที่ตรวจสอบสองครั้งทำงานได้ดี

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

ตัวอย่าง:

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

    public:
        INS(CCtrl);

คลาส singleton แบบง่ายต้องเป็นไฟล์คลาสส่วนหัวของคุณ

#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

เข้าถึงซิงเกิลของคุณแบบนี้:

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

ฉันคิดว่าคุณควรเขียนฟังก์ชั่นแบบคงที่ในกรณีที่วัตถุแบบสแตติกของคุณถูกลบ คุณควรเรียกใช้ฟังก์ชันนี้เมื่อคุณกำลังจะปิดแอปพลิเคชันของคุณ สิ่งนี้จะช่วยให้แน่ใจว่าคุณไม่มีการรั่วไหลของหน่วยความจำ