singleton 类

•  what is singleton class(and how will u write this)

Singleton
The term Singleton refers to an object that can only be instantiated once. This pattern is generally used where a global variable would have otherwise been used. The main advantage of the singleton is that its existence is guaranteed. Other advantages of the design pattern include the clarity, from the unique access, that the object used is not on the local stack. Some of the downfalls of the object include that, like a global variable, it can be hard to tell what chunk of code corrupted memory, when a bug is found, since everyone has access to it.

Let's take a look at how a Singleton differs from other variable types.
Like a global variable, the Singleton exists outside of the scope of any functions. Traditional implementation uses a static member function of the Singleton class, which will create a single instance of the Singleton class on the first call, and forever return that instance. The following code example illustrates the elements of a C++ singleton class, that simply stores a single string.

class StringSingleton
{
        public:
                // Some accessor functions for the class, itself
                std::string GetString() const {return mString;}
                void SetString(const std::string &newStr) {mString = newStr;}

                // The magic function, which allows access to the class from anywhere
                // To get the value of the instance of the class, call:
                // StringSingleton::Instance().GetString();
                static StringSingleton &Instance()
                {
                        // This line only runs once, thus creating the only instance in existence
                        static StringSingleton *instance = new StringSingleton;
                        // dereferencing the variable here, saves the caller from having to use
                        // the arrow operator, and removes tempation to try and delete the
                        // returned instance.
                        return *instance; // always returns the same instance
                }

        private:
                // We need to make some given functions private to finish the definition of the singleton
                StringSingleton(){} // default constructor available only to members or friends of this class

                // Note that the next two functions are not given bodies, thus any attempt
                // to call them implicitly will return as compiler errors. This prevents
                // accidental copying of the only instance of the class.
                StringSingleton(const StringSingleton &old); // disallow copy constructor
                const StringSingleton &operator=(const StringSingleton &old); //disallow assignment operator

                // Note that although this should be allowed,
                // some compilers may not implement private destructors
                // This prevents others from deleting our one single instance, which was otherwise created on the heap
                ~StringSingleton(){}
        private: // private data for an instance of this class
                std::string mString;
};