Single-Case mode

Singleton mode is one of the common design patterns in iOS. The role of a singleton design pattern is to make an object of this class the only instance in the system, so it is necessary to create the object in a unique way and return the address of the object. So, when do we use singleton mode? 1. A class can have only one instance, and it must be accessed from a well-known access point. 2. This unique instance can only be extended by subclasses, and the extended object does not break the client code.

So how do you implement a singleton pattern with objective-c? Let's create a new singleton class, implemented in Singleton.h as follows

1. @interface Singleton:nsobject
3. + (Singleton *) sharedinstance;
5. @end

In SINGLETON.M

2. @implementation Singleton
6. Static Singleton * Sharedsingleton = nil;
10. + (Singleton *) sharedinstance
12. {
14. if (Sharedsingleton = = nil) {
16. Sharedsingleton = [[Singleton alloc] init];
18. }
20. return Sharedsingleton;
22. }
26. @end

This creates a simple singleton pattern that is actually implemented by some programmers, but in fact it is not a "strict" version, and in practice, it is possible to encounter an object that initiates a call that cannot instantiate a singleton object in another way, or create multiple instances. (Someone has discussed this problem with me before, saying that the user should strictly follow the interface to use, when actually singleton is an object, we can not guarantee that the user will not use other methods to create (such as Alloc), this time he will create multiple instances, This will cause these imperceptible bugs to occur)

Now I'm making improvements to SINGLETON.M.

2. @implementation Singleton
6. Static Singleton * Sharedsingleton = nil;
10. + (Singleton *) sharedinstance
12. {
14. if (Sharedsingleton = = nil) {
16. Sharedsingleton = [[super Allocwithzone:NULL] init];
18. }
20. return Sharedsingleton;
22. }
26. + (ID) allocwithzone: (struct _nszone *) zone
28. {
30. return [[self sharedinstance] retain];
32. }
36. -(ID) copywithzone: (nszone *) zone
38. {
40. return self ;
42. }
46. -(ID) retain
48. {
50. return self ;
52. }
56. -(Nsuinteger) Retaincount
58. {
60. return Nsuintegermax;
62. }
68. -(void) Release
70. {
72. //  
74. }
78. -(ID) autorelease
80. {
82. return self ;
84. }
88. @end

Maybe you noticed, I overloaded the Allocwithzone: The Singleton object returned from the Sharedinstance method is maintained, and the user returns a unique instance even when using Alloc (the Alloc method calls Allocwithzone: Create object first). and retain and other memory management functions are overloaded, so that we have the Singleton class to become "strict".

Single-Case mode