Design ConsiderationsThe constructo

Design Considerations
The constructor is responsible for all the initialization operations of the Singleton object. For example, if we're creating a Singleton print spooler, it will create an empty job queue, check the status of all the currently active printers, etc. Because the constructor is protected, a client that tries to instantiate Singleton object directly will get a compilation error. Note that this constructor will get called on the first call to Instance().

Storing a pointer rather than an actual object has two advantages. First, it enables Singleton to use lazy instantiation. Secondly, it supports polymorphism -- you may assign the pointer to a subclass of Singleton.

The Design Patterns literature elegantly ignores the issue of a Singleton's destructor. This isn't a trivial issue, as it may seem at first. Remember that if you intend to derive classes from Singleton, you must declare its destructor virtual. Alternatively, you may forgo destructors both in the base class and its descendants. However, if you do define a destructor, don't be tempted to use it to destroy the Singleton object. The problem is that calling:

delete _instance;
will invoke the destructor, which in turn will try to delete _instance once more, infinitely. That said, don't ignore the fact that Instance() allocates an object on the free-store, and that that object must be deleted explicitly to avoid a memory leak. The simplest solution is to delete _instance at the end of the program:

int main()
{
Singleton *p = Singleton::Instance();
//..use p
delete p;
}
This is however, a violation of basic OOD principles. Imagine what would happen if another thread calls Instance() one again. A better solution is to define another static member function that explicitly destroys the Singleton object and resets _instance:

void Singleton::Destroy()
{
delete _instance;
_instance=0;
}
This way, a subsequent call to Instance() will work as expected, because it checks whether _instance is 0 before returning. Another solution that is suitable for single-threaded environments is to use a local static object:

//using a static Singleton object
//not suitable for multithreaded apps
Singleton* Singleton::Instance ()
{
static Singleton s;
return &s; // _instance isn't needed in this case
}

ผลลัพธ์ (ไทย) 1:

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

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

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

ลบ _instance;
จะเรียก destructor ที่จะพยายามที่จะลบ _instance สักที เพียบ ที่กล่าวว่า ไม่ละเว้นความจริงที่ว่า Instance() จัดสรรวัตถุบนฟรีร้านค้า และว่า ต้องถูกลบอย่างชัดเจนเพื่อหลีกเลี่ยงการรั่วไหลของหน่วยความจำ วิธีที่ง่ายที่สุดคือการ ลบ _instance ที่สุดของโปรแกรม:

int main()
{
เดี่ยว * p = Singleton::Instance();
/ / ...ใช้ p
ลบ p;
}
เป็นอย่างไรก็ตาม การละเมิดหลักการพื้นฐาน OOD จินตนาการอะไรจะเกิดขึ้นหากเธรดอื่นเรียก Instance() หนึ่งอีกด้วย อ่านจะกำหนดฟังก์ชันสมาชิกถาวรอื่นที่ทำลายวัตถุเดี่ยวอย่างชัดเจน และรีเซ็ต _instance:

ยกเลิกเดี่ยว:: Destroy()
{
ลบ _instance;
_instance = 0;
}
วิธีนี้ การเรียก Instance() ตามมาจะทำงานตามที่คาดไว้ เนื่องจากจะตรวจสอบว่า _instance เป็น 0 ก่อน แก้ไขปัญหาที่เหมาะสมสำหรับสภาพแวดล้อมแบบเธรดเดียวจะใช้วัตถุคงท้องถิ่น:

/ / ใช้วัตถุเดี่ยวคง
/ / ไม่เหมาะสมสำหรับปพลิเคชันให้
()เดี่ยว * Singleton::Instance
{
คงเดี่ยว s;
กลับ &s; / / _instance ไม่จำเป็นในกรณีนี้
}

ผลลัพธ์ (ไทย) 2:

ข้อควรพิจารณาเกี่ยวกับการออกแบบ Constructor
ซึ่งจะช่วยให้มีหน้าที่รับผิดชอบในการดำเนินงานการเริ่มต้นใช้งานทั้งหมดของวัตถุที่โดดเดี่ยว ตัวอย่างเช่นหากเรากำลังสร้าง Print Spooler โทนจะสร้างคิวงานหมดให้ตรวจสอบสถานะของเครื่องพิมพ์ที่ใช้งานอยู่ในปัจจุบันทั้งหมดเป็นต้นเพราะผู้สร้างจะได้รับการป้องกันเครื่องลูกข่ายที่จะพยายามที่จะโดดเดี่ยว instantiate วัตถุโดยตรงจะได้รับข้อความแสดงข้อผิดพลาดที่รวบรวมบันทึกไว้ด้วยว่าผู้สร้างแห่งนี้จะได้รับเรียกว่าในสายแรกที่จะยกตัวอย่างเช่น().

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

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

ลบ _instance
จะเรียกใช้ destructor ซึ่งในการเปิดจะพยายามลบ _instance อีกครั้งไม่สิ้นสุด ที่บอกว่าทำไม่ได้ไม่สนใจความจริงที่ว่ายกตัวอย่างเช่น()จัดสรรวัตถุที่อยู่ในแบบไม่เสียค่าบริการ - จัดเก็บและวัตถุที่จะต้องถูกลบออกอย่างชัดเจนเพื่อหลีกเลี่ยงการรั่วซึมหน่วยความจำ โซลูชันที่ง่ายที่สุดคือการลบ _instance ในช่วงปลายของโปรแกรม:

Int หลัก()

โทน*{ P =โทน::ยกตัวอย่างเช่น();

// ..use Pลบ P ;
}
แห่งนี้แต่ถึงอย่างไรก็ตามยังเป็นการละเมิดหลักการพื้นฐาน Are They . ลองจินตนาการดูว่าจะเกิดอะไรขึ้นหากเส้นอื่นการโทรตัวอย่างเช่น()หนึ่งอีกครั้ง มีการใช้โซลูชันที่ดีขึ้นในการกำหนดอีกแบบสแตติกสมาชิกที่ใช้งานอย่างชัดเจนทำลายที่โดดเดี่ยววัตถุและรีเซ็ต _instance :

เป็นโมฆะโทน::ทำลาย()
{
ลบ _instance ;
_instance = 0 ;
}
ตามวิธีการนี้ต่อไปการโทรไปยังตัว()จะทำงานอย่างที่คาดไว้ให้เพราะจะตรวจสอบว่า _instance คือ 0 ก่อนเดินทางกลับสู่ โซลูชันอื่นที่เหมาะสมสำหรับแบบซิงเกิลเธรด สภาพแวดล้อม คือการใช้ที่ท้องถิ่นแบบสแตติกออบเจกต์:

//โดยใช้ไฟฟ้าสถิตย์โทนออบเจกต์ http //
ไม่เหมาะสำหรับแบบมัลติเธรด( multithreaded ) apps
singleton *โทน:::ยกตัวอย่างเช่น()

แบบสแตติกโทน{ s ;
กลับไป &s ;// _instance ไม่จำเป็นในกรณีนี้
}