Destruktor for statiske felt. Singleton realisering

 C Programming >> C C# Program >  >> Tags >> struct
Destruktor for statiske felt. Singleton realisering

En minnelekkasje er mer enn bare en tildeling uten matchende gratis. Det er når du har minne som kan gjenvinnes fordi objektet ikke lenger er i bruk, men som faktisk aldri blir frigjort. Faktisk er mange minnelekkasjer tilfeller der det er kode i programmet for å deallokere minne, men uansett grunn blir det ikke kalt (for eksempel en referansesyklus). Det er mye forskning på hvordan man oppdager slike lekkasjer; dette papiret er et utmerket eksempel på et slikt verktøy.

Når det gjelder en singleton, har vi ingen lekkasje fordi den singletonen eksisterer gjennom hele programmet. Dens levetid er aldri ment å ta slutt, og derfor er det ikke noe problem at minnet ikke blir gjenvunnet.

Når det er sagt, koden du har ovenfor er ikke hvordan folk flest ville implementert en singleton. Den kanoniske C++-implementeringen vil være omtrent slik:

class Singleton
{
private:
    /* No instantiation. */
    Singleton() {}

    /* Explicitly disallow copying. */ 
    Singleton(const Singleton&) = delete;
    Singleton& operator= (const Singleton&) = delete;

    /* In C++03, the above would be written as
     *
     *    Singleton(const Singleton&);
     *    Singleton& operator= (const Singleton&);
     * 
     * and you'd just leave the methods unimplemented.
     */
public:
    static Singleton& getInstance();        
};

.cpp-fil:

Singleton& Singleton::getInstance() {
    /* Have a static local variable representing the unique instance.  Since
     * it's static, there is only one instance of this variable.  It's also only
     * initialized when getInstance is called.
     */
    static Singleton theInstance;
    return theInstance;
}

Nå er det ingen dynamisk tildeling i det hele tatt - minnet tildeles av kompilatoren og ligger sannsynligvis i koden eller datasegmentet i stedet for i haugen. Vær også oppmerksom på at du eksplisitt må nekte kopiering, ellers kan du ende opp med mange kloner av singletonen.

Den andre fordelen med dette er at C++ garanterer at ved programavslutning (forutsatt at programmet avsluttes normalt), destruktoren for theInstance vil faktisk avfyres på slutten av programmet. Du kan dermed definere en destruktor med all oppryddingskoden du trenger.

Håper dette hjelper!


Hvorfor bør du unngå slik kode, når det ikke er noen samsvarende delete for new

Selv om det ikke er noen faktisk minnelekkasje (i de fleste moderne operativsystemer), det verre er at Singleton destructor blir ikke oppringt. Og hvis du skaffer deg noen ressurser, ville det de sannsynligvis lekkasje.

Hva kan gjøres her

Bruk smart pointer for å lagre forekomst, tenk på std::unique_ptr (med C++11) eller boost::auto_ptr