Одиночный элемент C++ по сравнению с глобальным статическим объектом

В C ++ порядок создания экземпляров статических объектов в различных единицах компиляции не определен. Таким образом, один глобальный объект может ссылаться на другой, который не сконструирован, и взорвать вашу программу. Шаблон singleton устраняет эту проблему, связывая конструкцию со статической функцией-членом или свободной функцией.

Здесь есть достойное резюме .

На самом деле, в C ++ предпочтительным способом является локальный статический объект.

Printer & thePrinter() {
    static Printer printer;
    return printer;
}

Технически это синглтон, хотя эта функция может даже быть статическим методом класса. Таким образом, он гарантирует создание перед использованием, в отличие от глобальных статических объектов, которые могут быть созданы в любом порядке, что делает возможным непоследовательный отказ, когда один глобальный объект использует другой, довольно распространенный сценарий.

Что делает его лучше, чем обычный способ. выполнения синглтонов с созданием нового экземпляра путем вызова new заключается в том, что деструктор объекта будет вызываться в конце программы. Этого не произойдет с динамически выделяемым синглтоном.

Еще одна положительная сторона - нет возможности получить доступ к синглтону до его создания, даже из других статических методов или из подклассов. Экономит время на отладку.

Мой друг сегодня спросил меня, почему он должен предпочесть использование синглтона над глобальным статическим объектом? Я начал объяснять, что синглтон может иметь состояние, а статический глобальный объект не будет ... но тогда я не был уверен ... потому что это на C ++ ... (я пришел с C #)

Статический глобальный объект также может иметь состояние в C #:

class myclass {
 // can have state
 // ...
 public static myclass m = new myclass(); // globally accessible static instance, which can have state
}

Каковы преимущества одного перед другим? (в C ++)

Синглтон наносит вред вашему коду, а глобальный статический экземпляр - нет.

class myclass {
 // can have state
 // ...
 public static myclass m = new myclass(); // globally accessible static instance, which can have state
}

Каковы преимущества одного перед другим? (в C ++)

Синглтон наносит вред вашему коду, а глобальный статический экземпляр - нет.

class myclass {
 // can have state
 // ...
 public static myclass m = new myclass(); // globally accessible static instance, which can have state
}

Каковы преимущества одного перед другим? (в C ++)

Синглтон наносит вред вашему коду, а глобальный статический экземпляр - нет. На SO уже есть бесчисленные вопросы о проблемах с синглтонами. Вот один , и другой , или еще .

Короче говоря, синглтон дает вам две вещи:

• глобально доступный объект и
• гарантия того, что может быть создан только один экземпляр.

Если нам нужна только первая точка, мы должны создать глобально доступный объект. И зачем нам второй? Мы не заранее знаем , как наш код может быть использован в будущем, так зачем пригвоздить его и удалить то, что может быть полезным? Обычно мы ошибаемся , когда прогнозируем, что «мне понадобится только один экземпляр». И есть большая разница между «Мне нужен только один экземпляр» (правильный ответ - создать один экземпляр) и «приложение ни при каких обстоятельствах не может работать правильно, если более одного экземпляра Создан. Он выйдет из строя, отформатирует жесткий диск пользователя и опубликует конфиденциальные данные в Интернете »(ответ здесь такой: скорее всего, ваше приложение не работает, но если нет, то да, синглтон это то, что вам нужно)

Еще одно преимущество синглтона над глобальным статическим объектом заключается в том, что поскольку конструктор является частным , существует очень четкая директива компилятора, которая гласит: «Может быть только один».

По сравнению с глобальным статическим объектом, ничто не помешает разработчику написать код, который создает дополнительный экземпляр этого объекта.

1221] Преимущество дополнительного ограничения заключается в том, что у вас есть гарантия того, как объект будет использоваться.

Используя идиому синглтона («создание при первом использовании»), вы можете избежать фиаско статического порядка инициализации

Причина 1:
Синглтоны легко сделать, поэтому строить их не нужно.
Хотя вы можете сделать это с помощью глобальных переменных, разработчик потребует дополнительной работы. Поэтому по умолчанию глобальные переменные всегда инициализируются (кроме некоторых специальных правил с пространствами имен).

Итак, если ваш объект большой и / или дорогостоящий в строительстве, возможно, вы не захотите его строить, если вам действительно не нужно его использовать.

Причина 2:
Проблема с порядком инициализации (и уничтожения).

GlobalRes& getGlobalRes()
{
    static GlobalRes instance;  // Lazily initialized.
    return instance;
}


GlobalResTwo& getGlobalResTwo()
{
    static GlobalResTwo instance;  // Lazy again.
    return instance;
}


// Order of destruction problem.
// The destructor of this object uses another global object so
// the order of destruction is important.
class GlobalResTwo
{
    public:
        GlobalResTwo()
        {
            getGlobalRes();
            // At this point globalRes is fully initialized.
            // Because it is fully initialized before this object it will be destroyed
            // after this object is destroyed (Guaranteed)
        }
        ~GlobalResTwo()
        {
            // It is safe to use globalRes because we know it will not be destroyed
            // before this object.
            getGlobalRes().doStuff();
        }
};

OK, there are two reasons to go with a singleton really. One is the static order thing everyone's talking about.

The other is to prevent someone from doing something like this when using your code:

CoolThing blah;
gs_coolGlobalStaticThing = blah;

or, even worse:

gs_coolGlobalStaticThing = {};

The encapsulation aspect will protect your instance from idiots and malicious jerks.

В C ++ нет большой разницы между ними с точки зрения фактической полезности. Глобальный объект, конечно, может поддерживать свое собственное состояние (возможно, с другими глобальными переменными, хотя я не рекомендую это делать). Если вы собираетесь использовать глобальный или синглтон (и есть много причин не делать этого), самая большая причина использовать синглтон поверх глобального объекта заключается в том, что с синглтоном вы можете получить динамический полиморфизм, имея несколько классов, унаследованных от одноэлементный базовый класс.