Tabla de contenido
1. Introducción al patrón singleton
2. Implementación del modo singleton
1. Introducción al patrón singleton
A veces, cuando hacemos proyectos Qt, necesitamos usar muchas clases, por ejemplo, las clases que usamos son A, B, C y D. Entre ellas, A es la clase que debe usarse en B, C y D. Clase A Muy popular. Sin embargo, la Clase A ocupa mucha memoria. Definir un objeto A requiere 500 M de memoria. Si un objeto de Clase A se define en B, C y D, el consumo de memoria es concebible.
Por lo tanto, es imposible que B, C y D definan respectivamente un objeto de clase A. Entonces, en este momento esperamos: ¿Podemos definir A como una "variable global", de modo que las clases B, C y D puedan todas? acceder a él, y ¿Hay solo una A en todo el programa?
La respuesta es sí, al definir A, simplemente defínala en modo singleton.
Como patrón de diseño de software comúnmente utilizado, el modo singleton se utiliza principalmente para garantizar que solo haya una instancia en el sistema. Por ejemplo, generalmente solo hay una instancia de salida de registro en un programa y solo hay una instancia de conexión de base de datos en un sistema. En este caso, es muy importante utilizar el modo singleton.
¿Para qué se utiliza el patrón singleton?
Como se mencionó anteriormente, el patrón singleton:
(1) Todo el programa tiene un solo objeto;
(2) Todo el programa puede acceder a él;
(3) Dividido en "modo perezoso" y "modo hombre hambriento";
(4) El "modo diferido" consiste en crear un singleton solo cuando se usa; de lo contrario, no se creará ningún objeto;
(5) El "Modo Hombre Hambriento" requiere la creación de variables cuando se inicia el programa;
El modo del hombre perezoso es intercambiar tiempo por espacio, y el modo del hombre hambriento es intercambiar espacio por tiempo.
El patrón singleton se usa mucho en proyectos grandes, por ejemplo:
(1) Debe haber solo una clase de registro de diario en todo el programa. Si hay dos, se "pisotearán" entre sí al escribir archivos de registro.
(2) Debe haber solo una operación de base de datos y una clase de conexión en todo el programa. Si hay dos, habrá problemas. Desea ver qué sucederá si dos procesos usan la misma cuenta al mismo tiempo y luego escriben la mismos datos....
El modo singleton resuelve efectivamente el problema de definir objetos repetidamente. Si se combina con un bloqueo mutex, también puede resolver el problema de sincronización y exclusión mutua entre múltiples procesos y subprocesos, es decir, solo un proceso puede operar el objeto singleton al mismo tiempo . al mismo tiempo.
2. Implementación del modo singleton
Diseñar el patrón singleton es muy simple:
ejemplo de archivo cpp:
//这句一定要写,因为 self 是静态变量,必须要初始化值
ClassA* ClassA::self = NULL;
ClassA *ClassA::getInstance()
{
//判断是否是第一次调用
//假如不为 NULL,会直接 return
if (self == NULL) {
//防止多进程同时调用创建 2 个对象的问题
//原理是因为是静态变量只会定义一次
static QMutex mutex;
//上锁
QMutexLocker locker(&mutex);
//在判断一次,防止其它进程抢先 new 过了
if (self == NULL) {
self = new ClassA;
}
}
return self; //返回指针
}Ejemplo de archivo de encabezado h:
class ClassA : public QObject
{
Q_OBJECT
public:
//通过它获取 self 指针,这个函数是静态调用,不需要创建对象就可以访问
static ClassA *getInstance(); //返回自身的指针
//构造函数
explicit ClassA(QObject *parent = 0);
void hello(){ //一个普通函数
qDebug() << "hello world";
}
private:
static ClassA *self; //静态指针
};
#endif // ICONFONT_HMétodos de llamada en otras clases:
ClaseA::getInstance()->hola();
en:
ClassA::getInstance() obtendrá el autopuntero global, a través del cual podemos acceder a las funciones internas. En cualquier clase, puede acceder al objeto A incondicionalmente, no es necesario crear un objeto A y solo hay una instancia del objeto A globalmente:
(1) Defina un puntero estático en la clase A;
(2) Al llamar para obtener el puntero del objeto A, determine si el yo está vacío. Si está vacío, cree un nuevo objeto y asígnelo a uno mismo y devuelva uno mismo. Si existe, devuelva uno mismo directamente;
Aquí utilizamos el "modo diferido" más utilizado para demostración:
El código cpp es el siguiente (tomando la base de datos como ejemplo (esta clase se usa en múltiples interfaces UI)):
#include "qmqttclient.h"
#include <QMutex>
#include <QMutexLocker>
#include <QMessageBox>
//构造函数
QmqttClient::QmqttClient()
{
}
//这句一定要写,因为 self 是静态变量,必须要初始化值
QmqttClient* QmqttClient::mqttSelf = NULL;
QmqttClient *QmqttClient::getInstance()
{
//判断是否是第一次调用
//假如不为 NULL,会直接 return
if (mqttSelf == NULL) {
//防止多进程同时调用创建 2 个对象的问题
//原理是因为是静态变量只会定义一次
static QMutex mutex;
//上锁 QMutexLocker 会锁住 mutex，当 QMutexLocker 被释放的时候自动解锁
//locker 是局部变量，所以 getInstance 函数结束时会自动解锁
QMutexLocker locker(&mutex);
//在判断一次,防止其它进程抢先 new 过了
if (mqttSelf == NULL) {
mqttSelf = new QmqttClient;
}
}
return mqttSelf; //返回指针
}
archivo principal
#ifndef QMQTTCLIENT_H
#define QMQTTCLIENT_H
#include <QObject>
#include "qmqtt.h"
#include <QtCore>
class QmqttClient : public QObject{
Q_OBJECT
public:
//通过它获取 self 指针，这个函数是静态调用，不需要创建对像就可以访问，函数名
自定义
//这个函数的作用是给别人获取它的静态对象 返回自身的指针
static QmqttClient *getInstance();
// void hello(){ //一个普通函数
// qDebug() << "hello world";
private:
QmqttClient(); //构造函数，写在 private 下，不允许 new 生成单例
static QmqttClient *mqttSelf;//静态指针
};
Métodos de llamada en otras clases:
QmqttClient::getInstance()->mqttClient->setHost(ui->lEditServerIP->text()); //IP del servidor QmqttClient::getInstance()->mqttClient->setPort(1883);//Número de puerto
Entre ellos: QmqttClient::getInstance() obtendrá el autopuntero global, a través del cual podemos acceder a las funciones internas. En cualquier clase, puede acceder incondicionalmente al objeto A, y no es necesario crear un objeto A, y el Un objeto globalmente solo tiene Un ejemplo: Nota: Puede poner varios objetos en modo singleton