Ejemplo de calculadora
El ejemplo muestra cómo utilizar señales y ranuras para implementar la funcionalidad de un widget de calculadora, y cómo utilizar « QGridLayout » para colocar widgets secundarios en una cuadrícula.

Captura de pantalla del ejemplo de la calculadora
El ejemplo consta de dos clases:
Calculatores el widget de la calculadora, con toda la funcionalidad de la calculadora.Buttones el widget utilizado para cada uno de los botones de la calculadora. Deriva de ` QToolButton`.
Comenzaremos repasando ` Calculator` y, a continuación, echaremos un vistazo a ` Button`.
Definición de la clase Calculadora
class Calculator : public QWidget
{
Q_OBJECT
public:
Calculator(QWidget *parent = nullptr);
private slots:
void digitClicked();
void unaryOperatorClicked();
void additiveOperatorClicked();
void multiplicativeOperatorClicked();
void equalClicked();
void pointClicked();
void changeSignClicked();
void backspaceClicked();
void clear();
void clearAll();
void clearMemory();
void readMemory();
void setMemory();
void addToMemory();La clase ` Calculator ` proporciona un widget de calculadora sencillo. Hereda de ` QDialog ` y tiene varias ranuras privadas asociadas a los botones de la calculadora. Se reimplementa ` QObject::eventFilter()` para gestionar los eventos del ratón en la pantalla de la calculadora.
Los botones se agrupan en categorías según su comportamiento. Por ejemplo, todos los botones numéricos (denominados desde ` 0 ` hasta ` 9`) añaden un dígito al operando actual. Para estos, conectamos varios botones a la misma ranura (p. ej., ` digitClicked()`). Las categorías son: dígitos, operadores unarios (Sqrt, x², 1/x), operadores aditivos (+, -) y operadores multiplicativos (×, ÷). Los demás botones tienen sus propias ranuras.
private:
template<typename PointerToMemberFunction>
Button *createButton(const QString &text, const PointerToMemberFunction &member);
void abortOperation();
bool calculate(double rightOperand, const QString &pendingOperator);La función privada ` createButton() ` se utiliza como parte de la construcción del widget. Se llama a ` abortOperation() ` cada vez que se produce una división por cero o cuando se aplica una operación de raíz cuadrada a un número negativo. ` calculate() ` aplica un operador binario (+, -, × o ÷).
double sumInMemory;
double sumSoFar;
double factorSoFar;
QString pendingAdditiveOperator;
QString pendingMultiplicativeOperator;
bool waitingForOperand;Estas variables, junto con el contenido de la pantalla de la calculadora (un ` QLineEdit`), codifican el estado de la calculadora:
sumInMemorycontiene el valor almacenado en la memoria de la calculadora (utilizando MS, M+ o MC).sumSoFaralmacena el valor acumulado hasta el momento. Cuando el usuario hace clic en « = », se vuelve a calcular «sumSoFar» y se muestra en la pantalla. « Clear All » restablece «sumSoFar» a cero.factorSoFaralmacena un valor temporal al realizar multiplicaciones y divisiones.pendingAdditiveOperatoralmacena el último operador de suma en el que ha hecho clic el usuario.pendingMultiplicativeOperatoralmacena el último operador multiplicativo en el que ha hecho clic el usuario.waitingForOperandtruecuando la calculadora espera que el usuario comience a introducir un operando.
Los operadores aditivos y multiplicativos se tratan de forma diferente porque tienen distintas prioridades. Por ejemplo, « 1 + 2 ÷ 3 » se interpreta como « 1 + (2 ÷ 3) », ya que « ÷ » tiene mayor prioridad que « + ».
La tabla siguiente muestra la evolución del estado de la calculadora a medida que el usuario introduce una expresión matemática.
| Entrada del usuario | Pantalla | Suma hasta ahora | Operación de suma | Factor hasta ahora | Operación de multiplicación | ¿A la espera de un operando? |
|---|---|---|---|---|---|---|
| 0 | 0 | true | ||||
| 1 | 1 | 0 | false | |||
| 1 + | 1 | 1 | + | true | ||
| 1 + 2 | 2 | 1 | + | false | ||
| 1 + 2 ÷ | 2 | 1 | + | 2 | ÷ | true |
| 1 + 2 ÷ 3 | 3 | 1 | + | 2 | ÷ | false |
| 1 + 2 ÷ 3 - | 1,66667 | 1,66667 | - | true | ||
| 1 + 2 ÷ 3 - 4 | 4 | 1,66667 | - | false | ||
| 1 + 2 ÷ 3 - 4 = | -2,33333 | 0 | true |
Los operadores unarios, como Sqrt, no requieren ningún tratamiento especial; se pueden aplicar inmediatamente, ya que el operando ya se conoce al pulsar el botón del operador.
QLineEdit *display;
enum { NumDigitButtons = 10 };
Button *digitButtons[NumDigitButtons];
};Por último, declaramos las variables asociadas a la pantalla y a los botones utilizados para mostrar los números.
Implementación de la clase Calculadora
Calculator::Calculator(QWidget *parent)
: QWidget(parent), sumInMemory(0.0), sumSoFar(0.0)
, factorSoFar(0.0), waitingForOperand(true)
{En el constructor, inicializamos el estado de la calculadora. No es necesario inicializar explícitamente las variables ` pendingAdditiveOperator ` y ` pendingMultiplicativeOperator `, ya que el constructor ` QString ` las inicializa como cadenas vacías. También es posible inicializar esas variables directamente en el encabezado. Esto se denomina « member-initializaton » y evita una lista de inicialización demasiado larga.
display = new QLineEdit("0");
display->setReadOnly(true);
display->setAlignment(Qt::AlignRight);
display->setMaxLength(15);
QFont font = display->font();
font.setPointSize(font.pointSize() + 8);
display->setFont(font);Creamos el objeto ` QLineEdit `, que representa la pantalla de la calculadora, y configuramos algunas de sus propiedades. En concreto, lo configuramos como de solo lectura.
También aumentamos el tamaño de la fuente de ` display` en 8 puntos.
for (int i = 0; i < NumDigitButtons; ++i)
digitButtons[i] = createButton(QString::number(i), &Calculator::digitClicked);
Button *pointButton = createButton(tr("."), &Calculator::pointClicked);
Button *changeSignButton = createButton(tr("\302\261"), &Calculator::changeSignClicked);
Button *backspaceButton = createButton(tr("Backspace"), &Calculator::backspaceClicked);
Button *clearButton = createButton(tr("Clear"), &Calculator::clear);
Button *clearAllButton = createButton(tr("Clear All"), &Calculator::clearAll);
Button *clearMemoryButton = createButton(tr("MC"), &Calculator::clearMemory);
Button *readMemoryButton = createButton(tr("MR"), &Calculator::readMemory);
Button *setMemoryButton = createButton(tr("MS"), &Calculator::setMemory);
Button *addToMemoryButton = createButton(tr("M+"), &Calculator::addToMemory);
Button *divisionButton = createButton(tr("\303\267"), &Calculator::multiplicativeOperatorClicked);
Button *timesButton = createButton(tr("\303\227"), &Calculator::multiplicativeOperatorClicked);
Button *minusButton = createButton(tr("-"), &Calculator::additiveOperatorClicked);
Button *plusButton = createButton(tr("+"), &Calculator::additiveOperatorClicked);
Button *squareRootButton = createButton(tr("Sqrt"), &Calculator::unaryOperatorClicked);
Button *powerButton = createButton(tr("x\302\262"), &Calculator::unaryOperatorClicked);
Button *reciprocalButton = createButton(tr("1/x"), &Calculator::unaryOperatorClicked);
Button *equalButton = createButton(tr("="), &Calculator::equalClicked);Para cada botón, llamamos a la función privada ` createButton() ` con la etiqueta de texto adecuada y una ranura para conectarlo al botón.
QGridLayout *mainLayout = new QGridLayout;
mainLayout->setSizeConstraint(QLayout::SetFixedSize);
mainLayout->addWidget(display, 0, 0, 1, 6);
mainLayout->addWidget(backspaceButton, 1, 0, 1, 2);
mainLayout->addWidget(clearButton, 1, 2, 1, 2);
mainLayout->addWidget(clearAllButton, 1, 4, 1, 2);
mainLayout->addWidget(clearMemoryButton, 2, 0);
mainLayout->addWidget(readMemoryButton, 3, 0);
mainLayout->addWidget(setMemoryButton, 4, 0);
mainLayout->addWidget(addToMemoryButton, 5, 0);
for (int i = 1; i < NumDigitButtons; ++i) {
int row = ((9 - i) / 3) + 2;
int column = ((i - 1) % 3) + 1;
mainLayout->addWidget(digitButtons[i], row, column);
}
mainLayout->addWidget(digitButtons[0], 5, 1);
mainLayout->addWidget(pointButton, 5, 2);
mainLayout->addWidget(changeSignButton, 5, 3);
mainLayout->addWidget(divisionButton, 2, 4);
mainLayout->addWidget(timesButton, 3, 4);
mainLayout->addWidget(minusButton, 4, 4);
mainLayout->addWidget(plusButton, 5, 4);
mainLayout->addWidget(squareRootButton, 2, 5);
mainLayout->addWidget(powerButton, 3, 5);
mainLayout->addWidget(reciprocalButton, 4, 5);
mainLayout->addWidget(equalButton, 5, 5);
setLayout(mainLayout);
setWindowTitle(tr("Calculator"));
}El diseño lo gestiona un único ` QGridLayout`. La llamada a ` QLayout::setSizeConstraint()` garantiza que el widget ` Calculator ` se muestre siempre en su tamaño óptimo (su ` size hint`), lo que impide que el usuario cambie el tamaño de la calculadora. La sugerencia de tamaño viene determinada por el tamaño y la ` size policy ` de los widgets hijos.
La mayoría de los widgets secundarios ocupan solo una celda en el diseño de cuadrícula. Para estos, solo necesitamos pasar una fila y una columna a ` QGridLayout::addWidget()`. Los widgets ` display`, ` backspaceButton`, ` clearButton` y ` clearAllButton ` ocupan más de una columna; para estos, también debemos pasar un intervalo de filas y un intervalo de columnas.
void Calculator::digitClicked()
{
Button *clickedButton = qobject_cast<Button *>(sender());
int digitValue = clickedButton->text().toInt();
if (display->text() == "0" && digitValue == 0.0)
return;
if (waitingForOperand) {
display->clear();
waitingForOperand = false;
}
display->setText(display->text() + QString::number(digitValue));
}Al pulsar una de las teclas numéricas de la calculadora se emitirá la señal « clicked()» de dicha tecla, lo que activará la ranura « digitClicked() ».
En primer lugar, averiguamos qué botón ha enviado la señal utilizando QObject::sender(). Esta función devuelve al emisor como un puntero QObject. Como sabemos que el emisor es un objeto Button, podemos realizar con seguridad la conversión QObject. Podríamos haber utilizado una conversión al estilo C o un static_cast<>() de C++, pero como técnica de programación defensiva utilizamos un qobject_cast(). La ventaja es que, si el objeto es de un tipo incorrecto, se devuelve un puntero nulo. Los fallos debidos a punteros nulos son mucho más fáciles de diagnosticar que los debidos a conversiones inseguras. Una vez que tenemos el botón, extraemos el operador utilizando ` QToolButton::text()`.
La ranura debe tener en cuenta dos situaciones en particular. Si display contiene «0» y el usuario hace clic en el botón 0, sería absurdo mostrar «00». Y si la calculadora se encuentra en un estado en el que está esperando un nuevo operando, el nuevo dígito es el primer dígito de ese nuevo operando; en ese caso, primero debe borrarse cualquier resultado de un cálculo anterior.
Al final, añadimos el nuevo dígito al valor que aparece en la pantalla.
void Calculator::unaryOperatorClicked()
{
Button *clickedButton = qobject_cast<Button *>(sender());
QString clickedOperator = clickedButton->text();
double operand = display->text().toDouble();
double result = 0.0;
if (clickedOperator == tr("Sqrt")) {
if (operand < 0.0) {
abortOperation();
return;
}
result = std::sqrt(operand);
} else if (clickedOperator == tr("x\302\262")) {
result = std::pow(operand, 2.0);
} else if (clickedOperator == tr("1/x")) {
if (operand == 0.0) {
abortOperation();
return;
}
result = 1.0 / operand;
}
display->setText(QString::number(result));
waitingForOperand = true;
}La función « unaryOperatorClicked() » se invoca cada vez que se pulsa uno de los botones de operadores unarios. De nuevo, se recupera un puntero al botón pulsado mediante « QObject::sender()». El operador se extrae del texto del botón y se almacena en « clickedOperator ». El operando se obtiene de « display ».
A continuación, realizamos la operación. Si se aplica « Sqrt » a un número negativo o « 1/x » a cero, llamamos a « abortOperation() ». Si todo va bien, mostramos el resultado de la operación en el campo de edición de línea y establecemos « waitingForOperand » en « true ». Esto garantiza que, si el usuario introduce un nuevo dígito, este se considere un nuevo operando, en lugar de añadirse al valor actual.
void Calculator::additiveOperatorClicked()
{
Button *clickedButton = qobject_cast<Button *>(sender());
if (!clickedButton)
return;
QString clickedOperator = clickedButton->text();
double operand = display->text().toDouble();La ranura « additiveOperatorClicked() » se activa cuando el usuario hace clic en el botón « + » o « - ».
Antes de poder realizar ninguna acción con respecto al operador seleccionado, debemos gestionar cualquier operación pendiente. Comenzamos por los operadores multiplicativos, ya que tienen mayor prioridad que los operadores aditivos:
if (!pendingMultiplicativeOperator.isEmpty()) {
if (!calculate(operand, pendingMultiplicativeOperator)) {
abortOperation();
return;
}
display->setText(QString::number(factorSoFar));
operand = factorSoFar;
factorSoFar = 0.0;
pendingMultiplicativeOperator.clear();
}Si se ha pulsado antes × o ÷, sin pulsar después =, el valor actual en la pantalla es el operando derecho del operador × o ÷ y, por fin, podemos realizar la operación y actualizar la pantalla.
if (!pendingAdditiveOperator.isEmpty()) {
if (!calculate(operand, pendingAdditiveOperator)) {
abortOperation();
return;
}
display->setText(QString::number(sumSoFar));
} else {
sumSoFar = operand;
}Si se ha pulsado antes + o -, sumSoFar es el operando izquierdo y el valor actual en la pantalla es el operando derecho del operador. Si no hay ningún operador de suma pendiente, sumSoFar simplemente se establece como el texto que aparece en la pantalla.
pendingAdditiveOperator = clickedOperator;
waitingForOperand = true;
}Por último, podemos ocuparnos del operador en el que se acaba de hacer clic. Como aún no tenemos el operando de la derecha, almacenamos el operador seleccionado en la variable pendingAdditiveOperator. Aplicaremos la operación más tarde, cuando tengamos un operando de la derecha, con sumSoFar como operando de la izquierda.
void Calculator::multiplicativeOperatorClicked()
{
Button *clickedButton = qobject_cast<Button *>(sender());
if (!clickedButton)
return;
QString clickedOperator = clickedButton->text();
double operand = display->text().toDouble();
if (!pendingMultiplicativeOperator.isEmpty()) {
if (!calculate(operand, pendingMultiplicativeOperator)) {
abortOperation();
return;
}
display->setText(QString::number(factorSoFar));
} else {
factorSoFar = operand;
}
pendingMultiplicativeOperator = clickedOperator;
waitingForOperand = true;
}La ranura « multiplicativeOperatorClicked() » es similar a « additiveOperatorClicked() ». Aquí no tenemos que preocuparnos por los operadores aditivos pendientes, ya que los operadores multiplicativos tienen prioridad sobre los aditivos.
void Calculator::equalClicked()
{
double operand = display->text().toDouble();
if (!pendingMultiplicativeOperator.isEmpty()) {
if (!calculate(operand, pendingMultiplicativeOperator)) {
abortOperation();
return;
}
operand = factorSoFar;
factorSoFar = 0.0;
pendingMultiplicativeOperator.clear();
}
if (!pendingAdditiveOperator.isEmpty()) {
if (!calculate(operand, pendingAdditiveOperator)) {
abortOperation();
return;
}
pendingAdditiveOperator.clear();
} else {
sumSoFar = operand;
}
display->setText(QString::number(sumSoFar));
sumSoFar = 0.0;
waitingForOperand = true;
}Al igual que en additiveOperatorClicked(), empezamos por procesar cualquier operador multiplicativo y aditivo pendiente. A continuación, mostramos sumSoFar y restablecemos la variable a cero. Es necesario restablecer la variable a cero para evitar contar el valor dos veces.
void Calculator::pointClicked()
{
if (waitingForOperand)
display->setText("0");
if (!display->text().contains('.'))
display->setText(display->text() + tr("."));
waitingForOperand = false;
}La ranura « pointClicked() » añade un punto decimal al contenido de « display ».
void Calculator::changeSignClicked()
{
QString text = display->text();
double value = text.toDouble();
if (value > 0.0) {
text.prepend(tr("-"));
} else if (value < 0.0) {
text.remove(0, 1);
}
display->setText(text);
}La ranura « changeSignClicked() » cambia el signo del valor de « display ». Si el valor actual es positivo, le anteponemos un signo menos; si el valor actual es negativo, eliminamos el primer carácter del valor (el signo menos).
void Calculator::backspaceClicked()
{
if (waitingForOperand)
return;
QString text = display->text();
text.chop(1);
if (text.isEmpty()) {
text = "0";
waitingForOperand = true;
}
display->setText(text);
}La ranura « backspaceClicked() » elimina el carácter situado más a la derecha de la pantalla. Si se obtiene una cadena vacía, se muestra «0» y se establece « waitingForOperand » en « true ».
void Calculator::clear()
{
if (waitingForOperand)
return;
display->setText("0");
waitingForOperand = true;
}La ranura « clear() » restablece el operando actual a cero. Equivale a hacer clic en « Backspace » las veces necesarias para borrar todo el operando.
void Calculator::clearAll()
{
sumSoFar = 0.0;
factorSoFar = 0.0;
pendingAdditiveOperator.clear();
pendingMultiplicativeOperator.clear();
display->setText("0");
waitingForOperand = true;
}La ranura « clearAll() » restablece la calculadora a su estado inicial.
void Calculator::clearMemory()
{
sumInMemory = 0.0;
}
void Calculator::readMemory()
{
display->setText(QString::number(sumInMemory));
waitingForOperand = true;
}
void Calculator::setMemory()
{
equalClicked();
sumInMemory = display->text().toDouble();
}
void Calculator::addToMemory()
{
equalClicked();
sumInMemory += display->text().toDouble();
}La ranura « clearMemory() » borra la suma almacenada en memoria; « readMemory() » muestra la suma como un operando; « setMemory() » sustituye la suma en memoria por la suma actual; y « addToMemory() » suma el valor actual al valor almacenado en memoria. Para « setMemory() » y « addToMemory() », comenzamos llamando a « equalClicked() » para actualizar « sumSoFar » y el valor que aparece en la pantalla.
template<typename PointerToMemberFunction>
Button *Calculator::createButton(const QString &text, const PointerToMemberFunction &member)
{
Button *button = new Button(text);
connect(button, &Button::clicked, this, member);
return button;
}La función privada ` createButton() ` se invoca desde el constructor para crear los botones de la calculadora.
void Calculator::abortOperation()
{
clearAll();
display->setText(tr("####"));
}La función privada ` abortOperation() ` se invoca cada vez que falla un cálculo. Restablece el estado de la calculadora y muestra «####».
bool Calculator::calculate(double rightOperand, const QString &pendingOperator)
{
if (pendingOperator == tr("+")) {
sumSoFar += rightOperand;
} else if (pendingOperator == tr("-")) {
sumSoFar -= rightOperand;
} else if (pendingOperator == tr("\303\227")) {
factorSoFar *= rightOperand;
} else if (pendingOperator == tr("\303\267")) {
if (rightOperand == 0.0)
return false;
factorSoFar /= rightOperand;
}
return true;
}La función privada ` calculate() ` realiza una operación binaria. El operando derecho viene dado por ` rightOperand`. Para los operadores aditivos, el operando izquierdo es ` sumSoFar`; para los operadores multiplicativos, el operando izquierdo es ` factorSoFar`. La función devuelve ` false ` si se produce una división por cero.
Definición de la clase Button
Veamos ahora la clase « Button »:
class Button : public QToolButton
{
Q_OBJECT
public:
explicit Button(const QString &text, QWidget *parent = nullptr);
QSize sizeHint() const override;
};La clase ` Button ` cuenta con un constructor de conveniencia que toma una etiqueta de texto y un widget padre, y reimplementa ` QWidget::sizeHint()` para proporcionar más espacio alrededor del texto del que ofrece normalmente ` QToolButton `.
Implementación de la clase Button
Button::Button(const QString &text, QWidget *parent)
: QToolButton(parent)
{
setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Preferred);
setText(text);
}El aspecto de los botones viene determinado por el diseño del widget de la calculadora a través del tamaño y el ` size policy ` de los widgets hijos del diseño. La llamada a la función ` setSizePolicy()` en el constructor garantiza que el botón se expanda horizontalmente para ocupar todo el espacio disponible; por defecto, los ` QToolButton` no se expanden para ocupar el espacio disponible. Sin esta llamada, los distintos botones de una misma columna tendrían anchuras diferentes.
QSize Button::sizeHint() const
{
QSize size = QToolButton::sizeHint();
size.rheight() += 20;
size.rwidth() = qMax(size.width(), size.height());
return size;
}En sizeHint(), intentamos devolver un tamaño que quede bien para la mayoría de los botones. Reutilizamos la sugerencia de tamaño de la clase base (QToolButton), pero la modificamos de las siguientes maneras:
- Añadimos 20 al componente « height » de la sugerencia de tamaño.
- Hacemos que el componente « width » de la sugerencia de tamaño sea, como mínimo, igual que el de « height ».
Esto garantiza que, con la mayoría de las fuentes, los botones de dígitos y operadores sean cuadrados, sin truncar el texto de los botones « Backspace », « Clear » y « Clear All ».
La captura de pantalla siguiente muestra cómo se vería el widget Calculator si no hubiéramos establecido la política de tamaño horizontal en QSizePolicy::Expanding en el constructor y si no hubiéramos reimplementado QWidget::sizeHint().

El ejemplo de la calculadora con políticas de tamaño predeterminadas y sugerencias de tamaño
© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.