Шаблон Singleton обычно используется, когда вам нужен один общий ресурс, доступ к которому должен быть глобальным, например подключение к базе данных, средство ведения журнала или диспетчер конфигурации. Применяя один экземпляр, он позволяет нескольким частям программы получать доступ к одному и тому же объекту и изменять его, обеспечивая согласованность данных и уменьшая потребность в глобальных переменных. Синглтон можно использовать в качестве кэша объектов, где часто используемые или дорогостоящие в создании объекты хранятся и повторно используются во всем приложении. Этот подход помогает повысить производительность, избегая создания и инициализации избыточных объектов.
В этой статье мы объясним создание синглтона и продемонстрируем пример стилизации синглтона в программе на C++.
Пример 1. Создание простого синглтона с помощью Eager инициализации
Простой синглтон с ранней инициализацией — это шаблон проектирования, который гарантирует, что создается только один экземпляр класса, и он создается сразу во время статической инициализации.
Мы продемонстрируем базовый фрагмент кода для создания простого синглтона с быстрой инициализацией. Начнем с программы:
#include
класс Синглтон {
частный :
статический Синглтон * пример ;
Синглтон ( ) { }
общественный :
статический Синглтон * получить экземпляр ( ) {
возвращаться пример ;
}
} ;
Синглтон * Синглтон :: пример '=' новый синглтон ( ) ;
интервал основной ( ) {
Синглтон * синглтонэкземпляр1 '=' Синглтон :: получить экземпляр ( ) ;
Синглтон * синглтонэкземпляр2 '=' Синглтон :: получить экземпляр ( ) ;
стандартный :: расчет << 'singletonletonInstance1: ' << синглтонэкземпляр1 << стандартный :: конец ;
стандартный :: расчет << 'singletonletonInstance2: ' << синглтонэкземпляр2 << стандартный :: конец ;
возвращаться 0 ;
}
Код включает заголовок
После включения файла заголовка мы определяем класс Singleton, который представляет реализацию шаблона Singleton. Он имеет закрытый конструктор и частную статическую переменную-член с именем «экземпляр».
Затем функция getInstance() реализуется как публичная статическая функция-член класса Singleton. Он возвращает экземпляр синглтона, который хранится в экземпляре статической переменной-члена. Экземпляр статической переменной-члена определяется и инициализируется вне класса с помощью «Singleton* Singleton::instance = new Singleton();». Эта строка активно инициализирует экземпляр класса «Singleton» во время статической инициализации.
В функции main() мы объявляем два указателя, «singletonInstance1» и «singletonInstance2», и присваиваем значение, которое возвращается при вызове Singleton::getInstance(). Поскольку экземпляр инициализируется быстро, оба указателя указывают на один и тот же экземпляр. Операторы «std::cout» выводят на консоль адреса памяти «singletonInstance1» и «singletonInstance2», используя оператор «<<» и «std::endl».
Код заканчивается «возвратом 0», который указывает на успешное выполнение программы.
Когда вы запустите этот код, результат будет примерно таким:
В выводе отображаются адреса памяти «singletonInstance1» и «singletonInstance2». Поскольку обоим указателям присваивается один и тот же экземпляр, полученный из Singleton::getInstance(), они имеют один и тот же адрес памяти. Это демонстрирует, как шаблон Singleton гарантирует, что существует единственный экземпляр класса и что будущие вызовы getInstance() всегда приводят к одному и тому же экземпляру.
Пример 2. Реализация шаблона Singleton с ленивой инициализацией
В этой демонстрации объясняется реализация шаблона Singleton с ленивой инициализацией и показано его использование в функции main(). Пошаговое объяснение фрагмента кода приведено после этой программы:
#includeкласс Синглтон {
частный :
статический Синглтон * пример ;
Синглтон ( ) {
стандартный :: расчет << «Экземпляр Singleton создан». << стандартный :: конец ;
}
общественный :
статический Синглтон * получить экземпляр ( ) {
если ( пример == нульптр ) {
пример '=' новый синглтон ( ) ;
}
возвращаться пример ;
}
пустота показать сообщение ( ) {
стандартный :: расчет << «Привет от Синглтона!» << стандартный :: конец ;
}
~Синглтон ( ) {
стандартный :: расчет << «Экземпляр Singleton уничтожен». << стандартный :: конец ;
}
} ;
Синглтон * Синглтон :: пример '=' нульптр ;
интервал основной ( ) {
Синглтон * синглтонэкземпляр1 '=' Синглтон :: получить экземпляр ( ) ;
синглтонэкземпляр1 -> показать сообщение ( ) ;
Синглтон * синглтонэкземпляр2 '=' Синглтон :: получить экземпляр ( ) ;
синглтонэкземпляр2 -> показать сообщение ( ) ;
возвращаться 0 ;
}
Программа начинается с добавления заголовочного файла
Всякий раз, когда вызывается конструктор класса «Singleton», он генерирует экземпляр класса «Singleton». Он выводит сообщение «Экземпляр Singleton создан» на консоль, используя «std::cout << … << std::endl;». Конструктор не имеет никаких параметров, поскольку это конструктор по умолчанию. Он определяется как Singleton() без каких-либо аргументов. Мы объявляем его закрытым, что означает, что его можно вызвать только изнутри класса. Это предотвращает прямое создание экземпляра класса «Singleton» и гарантирует, что единственный способ получить экземпляр — через функцию getInstance().
Метод getInstance() класса Singleton объявлен как публичная статическая функция-член. Его роль заключается в установлении и предоставлении доступа к экземпляру-одиночке. Внутри getInstance() он проверяет, является ли экземпляр «nullptr». Если это так, что означает, что экземпляр еще не существует, он использует частный конструктор для создания экземпляра нового объекта класса «Singleton».
Функция showMessage() — это простая функция-член, которая отображает сообщение «Привет от Синглтона!» сообщение. Определен деструктор синглтона. Он вызывается неявно, когда программа завершает работу и печатает «Экземпляр Singleton уничтожен». сообщение, указывающее, что экземпляр Singleton уничтожен. Экземпляр статической переменной-члена изначально определяется как «nullptr».
int main() запускает определение функции main(). Затем «Singleton* singletonInstance1 = Singleton::getInstance();» вызывает функцию getInstance() класса Singleton, чтобы получить указатель на экземпляр синглтона. Он присваивает этот указатель переменной «singletonInstance1».
После этого «singletonInstance1->showMessage();» использует оператор стрелки (->) для вызова функции showMessage() по указателю «singletonInstance1». Эта функция выводит на консоль указанное в ней сообщение. После этого «Singleton* singletonInstance2 = Singleton::getInstance();» снова вызывает функцию getInstance(), получая еще один указатель на экземпляр синглтона. На этот раз он присваивает указатель переменной «singletonInstance2». «singletonInstance2->showMessage();» вызывает функцию showMessage() по указателю «singletonInstance2». Эта функция отображает сообщение «Привет от Синглтона!» еще раз отправить сообщение на консоль.
Наконец, «вернуть 0»; означает конец функции main(), и программа возвращает значение 0, что означает успешное выполнение программы.
Вот результат ранее объясненного фрагмента кода:
Этот результат подтверждает, что класс Singleton гарантирует создание только одного экземпляра и что дальнейшие вызовы функции getInstance() надежно дадут тот же экземпляр.
Заключение
Создание синглтона в C++ — очень полезная концепция. В этом посте мы изначально рассмотрели вводный раздел синглтона. Кроме того, приведены два примера реализации синглтона на C++. На первой иллюстрации показана реализация активной одноэлементной инициализации. Тогда как реализация ленивой инициализации шаблона Singleton представлена во втором примере этой статьи. Кроме того, снимки полученной продукции также отображаются для соответствующих программ.