Technology sharing

Design and Implementation of Singleton Pattern in C: From Basics to Advanced

2024-07-12

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

Design and implementation of singleton pattern in C++: from basics to advanced

Title: Intellectus singleton exemplar in C ++: consilium, exsecutionem et applicationem

In evolutione programmatum, rationes designandi solutiones ad specificas quaestiones probandas adiuvant. Singleton Pattern unum est ex exemplaribus fundamentalibus et late adhibitis consilio. Hoc efficit ut genus unum tantum habeat instantia et punctum accessum globalis praebet ut hoc instanciam obtineat.Articulus hic altiorem aspectum habebit quomodo Singleton exemplar in C++ deducendum sit, a basic exsecutione ad versiones tutas fila ad hodiernas C++ notas, quales indicia callidior etstd::call_once) applicatione et satagat lectoribus comprehensivo et practico duce providere.

1. notiones singleton forma

Media idea exemplaris singleton est curare ut genus unum tantum instantia habeat ac punctum accessum globalis praebeat. Hic modus utilis est cum accessum ad facultates regere debes (ut configuratio lectorum, caesuri, nexus datorum lacunis, etc.). Clavis ad singleton exemplar est:

  • Constructor ordinis privatus est, impediens codicem externum ne obiectum directe instantiat.
  • Instantiam staticam intra classem praebete et hoc instantia cum opus fuerit redde.
  • Publicum aditum praebere elit modum, plerumquegetInstance()obtinebat unicum genus.
2. Basic implementation

Primum, inspiciamus exsecutionem exemplaris simplicis singleton nisi consideratis quaestiones securitatis sequelae:

#include <iostream>

class Singleton {
private:
    // 私有构造函数，防止外部实例化
    Singleton() {}

    // 私有拷贝构造函数和赋值操作符，防止拷贝
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

    // 静态实例
    static Singleton* instance;

public:
    // 静态方法，返回类的唯一实例
    static Singleton* getInstance() {
        if (!instance) {
            instance = new Singleton();
        }
        return instance;
    }

    // 示例方法
    void doSomething() {
        std::cout << "Doing something..." << std::endl;
    }

    // 析构函数（通常是protected或public，取决于是否需要外部delete）
    ~Singleton() {
        std::cout << "Singleton destroyed." << std::endl;
    }
};

// 初始化静态实例
Singleton* Singleton::instance = nullptr;

int main() {
    Singleton* s1 = Singleton::getInstance();
    Singleton* s2 = Singleton::getInstance();

    if (s1 == s2) {
        std::cout << "s1 and s2 are the same instance." << std::endl;
    }

    s1->doSomething();
    // 注意：在多线程环境下，上述实现可能存在安全问题

    // 通常不推荐手动删除单例对象，除非有特别理由
    // delete Singleton::instance; // 谨慎使用

    return 0;
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
3. Post salus implementation

In ambitu multi-filato, exsecutio praedicta multiplex fila efficere potest ut simul ingredianturgetInstance() methodum et instantias pluries efficiunt.Ad hanc quaestionem solvendam, seram mutex uti possumus (utstd::mutex) Ad salutem sequela curare:

#include <mutex>
#include <iostream>

class Singleton {
private:
    Singleton() {}
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

    static Singleton* instance;
    static std::mutex mtx;

public:
    static Singleton* getInstance() {
        std::lock_guard<std::mutex> lock(mtx);
        if (!instance) {
            instance = new Singleton();
        }
        return instance;
    }

    void doSomething() {
        std::cout << "Doing something..." << std::endl;
    }

    ~Singleton() {
        std::cout << "Singleton destroyed." << std::endl;
    }
};

Singleton* Singleton::instance = nullptr;
std::mutex Singleton::mtx;

// main函数保持不变

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
4. Indicibus captiosus usus ad vitam cyclum administrare singleton

Ut automatice cyclum vitam objecti singletoni (i.e. automatice in fine programmatis deperditam curo), argumentis callidioribus uti possumus (utstd::unique_ptr) Rudis loco indicium:

#include <memory>
#include <mutex>
#include <iostream>

class Singleton {
private:
    Singleton() {}
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

    static std::unique_ptr<Singleton> instance;
    static std::mutex mtx;

public:
    static Singleton& getInstance() {
        std::lock_guard<std::mutex> lock(mtx);
        if (!instance) {
            instance = std::make_unique<Singleton>();
        }
        return *instance;
    }

    void doSomething() {
        std::cout << "Doing something..." << std::endl;
    }

    // 析构函数被智能指针管理，无需手动调用
    ~Singleton() {
        std::cout << "Singleton destroyed." << std::endl;
    }

    // 禁止拷贝和移动
    Singleton(Singleton&&) = delete;
    Singleton& operator=(Singleton&&) = delete;
};

std::unique_ptr<Singleton> Singleton::instance = nullptr;
std::mutex Singleton::mtx;

int main() {
    // 注意这里返回的是引用，无需使用指针
    Singleton& s1 = Singleton::getInstance();
    Singleton& s2 = Singleton::getInstance();

    if (&s1 == &s2) {
        std::cout << "s1 and s2 are the same instance." << std::endl;
    }

    s1.doSomething();

    // 程序结束时，智能指针会自动销毁Singleton实例

    return 0;
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
5. ususstd::call_onceipsum

Satus C ++ XI,std::call_once Efficaciorem et pressiorem rationem praebet ut munus semel tantum dicatur, etiam in ambitu multi- liciato. Hoc pluma utimur amplius ad optimize exsecutionem exemplaris singletonii:

#include <memory>
#include <mutex>
#include <iostream>
#include <once.h> // 注意：实际上应使用#include <mutex>中的std::call_once

class Singleton {
private:
    Singleton() {}
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

    static std::unique_ptr<Singleton> instance;
    static std::once_flag onceFlag;

    static void createInstance() {
        instance = std::make_unique<Singleton>();
    }

public:
    static Singleton& getInstance() {
        std::call_once(onceFlag, createInstance);
        return *instance;
    }

    void doSomething() {
        std::cout << "Doing something..." << std::endl;
    }

    // 析构函数和移动操作符的禁用同上
};

std::unique_ptr<Singleton> Singleton::instance = nullptr;
std::once_flag Singleton::onceFlag;

// main函数保持不变

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35

NOTA: In codice supra, perperam citatum#include <once.h>,<mutex>in header filestd::once_flagetstd::call_once。

6. Libri

Exemplar singleton perutile exemplar in C++ est Nihilominus, debes operam dare ad quaestiones securitatis sequelae, cum exemplum singleton exsequendum, praesertim in multi-filaminibus environment.Utendo Mutex crines, dolor indicium etstd::call_onceCum modernis C++ notis, exemplar singletonus tutius et efficacius efficere possumus.

Cum exemplar singleton designans, aliqua additamenta considerare debes, ut vita cycli administratio objecti singletonis (num ipso facto destrui debeat cum finium progressionum), num pigra oneratio conceditur (hoc est, creationem cunctando. instantiae, donec prius adhibeatur) etc. Accedit, in quibusdam casibus, varietates exemplaris singletonii considerare velis, sicut exemplar multi- exempli (quod instantiarum numerorum classium moderatur, sed certum modum superiorem non excedit) vel in contextu exemplaris singletontici substructio. quae reddit varia bona in diversis adiunctis fundata).

Articulus iste spero melius lectores iuvare ut exemplar singleton in C ++ intelligant ac mollius in actualibus inceptis utantur.

Personal profile

technologiae technologiae plus quam 30 annos operam dedit et in variis linguis proficit ut java, linux, javascript, php, css, etc. Multas contributiones in aperto fonte campo fecit elit documentorum statione ad communicandas quaestiones technologiarum progressus ad futuram referentiam

mihi contactus notitia

Mail