Ejemplo de resaltado de sintaxis
El ejemplo del resaltador de sintaxis muestra cómo realizar un resaltado de sintaxis sencillo.

La aplicación «Resaltador de sintaxis» muestra archivos C++ con resaltado de sintaxis personalizado.
El ejemplo consta de dos clases:
- La clase «
Highlighter» define y aplica las reglas de resaltado. - El widget «
MainWindow» es la ventana principal de la aplicación.
En primer lugar, repasaremos la clase « Highlighter » para ver cómo puedes personalizar la clase « QSyntaxHighlighter » según tus preferencias; a continuación, analizaremos las partes relevantes de la clase « MainWindow » para ver cómo puedes utilizar tu clase de resaltado personalizada en una aplicación.
Definición de la clase «Highlighter»
class Highlighter : public QSyntaxHighlighter
{
Q_OBJECT
public:
Highlighter(QTextDocument *parent = nullptr);
protected:
void highlightBlock(const QString &text) override;
private:
struct HighlightingRule
{
QRegularExpression pattern;
QTextCharFormat format;
};
QList<HighlightingRule> highlightingRules;
QRegularExpression commentStartExpression;
QRegularExpression commentEndExpression;
QTextCharFormat keywordFormat;
QTextCharFormat classFormat;
QTextCharFormat singleLineCommentFormat;
QTextCharFormat multiLineCommentFormat;
QTextCharFormat quotationFormat;
QTextCharFormat functionFormat;
};Para proporcionar tu propio resaltado de sintaxis, debes crear una subclase de ` QSyntaxHighlighter`, reimplementar la función ` highlightBlock()` y definir tus propias reglas de resaltado.
Hemos optado por almacenar nuestras reglas de resaltado utilizando una estructura privada: una regla consta de un patrón ` QRegularExpression ` y una instancia de ` QTextCharFormat `. A continuación, las distintas reglas se almacenan utilizando una ` QList`.
La clase QTextCharFormat proporciona información de formato para los caracteres de una QTextDocument, especificando las propiedades visuales del texto, así como información sobre su función en un documento de hipertexto. En este ejemplo, solo definiremos el grosor y el color de la fuente mediante las funciones QTextCharFormat::setFontWeight() y QTextCharFormat::setForeground().
Implementación de la clase `Highlighter`
Al crear una subclase de la clase QSyntaxHighlighter, debes pasar el parámetro «parent» al constructor de la clase base. El «parent» es el documento de texto al que se aplicará el resaltado de sintaxis. En este ejemplo, también hemos optado por definir nuestras reglas de resaltado en el constructor:
Highlighter::Highlighter(QTextDocument *parent)
: QSyntaxHighlighter(parent)
{
HighlightingRule rule;
keywordFormat.setForeground(Qt::darkBlue);
keywordFormat.setFontWeight(QFont::Bold);
const QString keywordPatterns[] = {
QStringLiteral("\\bchar\\b"), QStringLiteral("\\bclass\\b"), QStringLiteral("\\bconst\\b"),
QStringLiteral("\\bdouble\\b"), QStringLiteral("\\benum\\b"), QStringLiteral("\\bexplicit\\b"),
QStringLiteral("\\bfriend\\b"), QStringLiteral("\\binline\\b"), QStringLiteral("\\bint\\b"),
QStringLiteral("\\blong\\b"), QStringLiteral("\\bnamespace\\b"), QStringLiteral("\\boperator\\b"),
QStringLiteral("\\bprivate\\b"), QStringLiteral("\\bprotected\\b"), QStringLiteral("\\bpublic\\b"),
QStringLiteral("\\bshort\\b"), QStringLiteral("\\bsignals\\b"), QStringLiteral("\\bsigned\\b"),
QStringLiteral("\\bslots\\b"), QStringLiteral("\\bstatic\\b"), QStringLiteral("\\bstruct\\b"),
QStringLiteral("\\btemplate\\b"), QStringLiteral("\\btypedef\\b"), QStringLiteral("\\btypename\\b"),
QStringLiteral("\\bunion\\b"), QStringLiteral("\\bunsigned\\b"), QStringLiteral("\\bvirtual\\b"),
QStringLiteral("\\bvoid\\b"), QStringLiteral("\\bvolatile\\b"), QStringLiteral("\\bbool\\b")
};
for (const QString &pattern : keywordPatterns) {
rule.pattern = QRegularExpression(pattern);
rule.format = keywordFormat;
highlightingRules.append(rule);
}En primer lugar, definimos una regla de palabras clave que reconoce las palabras clave más comunes de C++. Asignamos a las palabras clave « keywordFormat » una fuente en negrita y de color azul oscuro. Para cada palabra clave, asignamos la palabra clave y el formato especificado a un objeto `HighlightingRule` y añadimos el objeto a nuestra lista de reglas.
classFormat.setFontWeight(QFont::Bold);
classFormat.setForeground(Qt::darkMagenta);
rule.pattern = QRegularExpression(QStringLiteral("\\bQ[A-Za-z]+\\b"));
rule.format = classFormat;
highlightingRules.append(rule);
quotationFormat.setForeground(Qt::darkGreen);
rule.pattern = QRegularExpression(QStringLiteral("\".*\""));
rule.format = quotationFormat;
highlightingRules.append(rule);
functionFormat.setFontItalic(true);
functionFormat.setForeground(Qt::blue);
rule.pattern = QRegularExpression(QStringLiteral("\\b[A-Za-z0-9_]+(?=\\()"));
rule.format = functionFormat;
highlightingRules.append(rule);A continuación, creamos un formato que aplicaremos a los nombres de clase de Qt. Los nombres de clase se mostrarán en color magenta oscuro y con negrita. Especificamos un patrón de cadena que, en realidad, es una expresión regular que captura todos los nombres de clases de Qt. A continuación, asignamos la expresión regular y el formato especificado a un objeto `HighlightingRule` y añadimos el objeto a nuestra lista de reglas.
También definimos reglas de resaltado para comillas y funciones utilizando el mismo enfoque: los patrones tienen la forma de expresiones regulares y se almacenan en objetos `HighlightingRule` junto con el formato asociado.
singleLineCommentFormat.setForeground(Qt::red);
rule.pattern = QRegularExpression(QStringLiteral("//[^\n]*"));
rule.format = singleLineCommentFormat;
highlightingRules.append(rule);
multiLineCommentFormat.setForeground(Qt::red);
commentStartExpression = QRegularExpression(QStringLiteral("/\\*"));
commentEndExpression = QRegularExpression(QStringLiteral("\\*/"));
}El lenguaje C++ cuenta con dos tipos de comentarios: el comentario de una sola línea (//) y el comentario de varias líneas (/*...*/ ). El comentario de una sola línea se puede definir fácilmente mediante una regla de resaltado similar a las anteriores. Sin embargo, el comentario de varias líneas requiere una atención especial debido al diseño de la clase ` QSyntaxHighlighter `.
Una vez creado un objeto ` QSyntaxHighlighter `, su función ` highlightBlock()` se llamará automáticamente siempre que sea necesario por parte del motor de texto enriquecido, resaltando el bloque de texto indicado. El problema surge cuando un comentario abarca varios bloques de texto. Analizaremos con más detalle cómo se puede resolver este problema al revisar la implementación de la función Highlighter::highlightBlock(). Por ahora, solo especificamos el color del comentario multilínea.
void Highlighter::highlightBlock(const QString &text)
{
for (const HighlightingRule &rule : std::as_const(highlightingRules)) {
QRegularExpressionMatchIterator matchIterator = rule.pattern.globalMatch(text);
while (matchIterator.hasNext()) {
QRegularExpressionMatch match = matchIterator.next();
setFormat(match.capturedStart(), match.capturedLength(), rule.format);
}
}La función `highlightBlock()` se invoca automáticamente siempre que lo requiera el motor de texto enriquecido, es decir, cuando hay bloques de texto que han cambiado.
En primer lugar, aplicamos las reglas de resaltado sintáctico que hemos almacenado en la lista « highlightingRules ». Para cada regla (es decir, para cada objeto «HighlightingRule»), buscamos el patrón en el bloque de texto dado utilizando la función « QString::indexOf()». Cuando se encuentra la primera aparición del patrón, utilizamos la función ` QRegularExpressionMatch::capturedLength()` para determinar la cadena que se va a formatear. ` QRegularExpressionMatch::capturedLength()` devuelve la longitud de la última cadena coincidente, o 0 si no ha habido ninguna coincidencia.
Para llevar a cabo el formato propiamente dicho, la clase ` QSyntaxHighlighter ` proporciona la función ` setFormat()`. Esta función opera sobre el bloque de texto que se pasa como argumento a la función ` highlightBlock() `. El formato especificado se aplica al texto a partir de la posición inicial indicada y durante la longitud indicada. Las propiedades de formato establecidas en el formato dado se fusionan en el momento de la visualización con la información de formato almacenada directamente en el documento. Ten en cuenta que el documento en sí no se ve modificado por el formato establecido mediante esta función.
Este proceso se repite hasta que se encuentra la última aparición del patrón en el bloque de texto actual.
setCurrentBlockState(0);Para gestionar construcciones que pueden abarcar varios bloques de texto (como el comentario multilínea de C++), es necesario conocer el estado final del bloque de texto anterior (p. ej., «en comentario»). Dentro de la implementación de ` highlightBlock() `, se puede consultar el estado final del bloque de texto anterior mediante la función ` QSyntaxHighlighter::previousBlockState()`. Tras analizar el bloque, se puede guardar el último estado utilizando ` QSyntaxHighlighter::setCurrentBlockState()`.
La función previousBlockState() devuelve un valor de tipo int. Si no se ha establecido ningún estado, el valor devuelto es -1. Puedes asignar cualquier otro valor para identificar un estado determinado mediante la función setCurrentBlockState(). Una vez establecido el estado, la función QTextBlock () mantiene ese valor hasta que se vuelva a establecer o hasta que se elimine el párrafo de texto correspondiente.
En este ejemplo hemos optado por utilizar 0 para representar el estado «fuera de comentario» y 1 para el estado «dentro de comentario». Cuando se aplican las reglas de resaltado sintáctico almacenadas, inicializamos el estado del bloque actual a 0.
int startIndex = 0;
if (previousBlockState() != 1)
startIndex = text.indexOf(commentStartExpression);Si el estado del bloque anterior era «en comentario» (previousBlockState() == 1), comenzamos la búsqueda de una expresión de fin al principio del bloque de texto. Si previousBlockState() devuelve 0, comenzamos la búsqueda en la ubicación de la primera aparición de una expresión de inicio.
while (startIndex >= 0) {
QRegularExpressionMatch match = commentEndExpression.match(text, startIndex);
int endIndex = match.capturedStart();
int commentLength = 0;
if (endIndex == -1) {
setCurrentBlockState(1);
commentLength = text.length() - startIndex;
} else {
commentLength = endIndex - startIndex
+ match.capturedLength();
}
setFormat(startIndex, commentLength, multiLineCommentFormat);
startIndex = text.indexOf(commentStartExpression, startIndex + commentLength);
}
}Cuando se encuentra una expresión de fin, calculamos la longitud del comentario y aplicamos el formato de comentario multilínea. A continuación, buscamos la siguiente aparición de la expresión de inicio y repetimos el proceso. Si no se encuentra ninguna expresión de fin en el bloque de texto actual, establecemos el estado del bloque actual en 1, es decir, «en comentario».
Con esto queda completada la implementación de la clase ` Highlighter `; ya está lista para su uso.
Definición de la clase MainWindow
Utilizar una subclase de ` QSyntaxHighlighter ` es sencillo; basta con proporcionar a la aplicación una instancia de la clase y pasarle el documento al que se desea aplicar el resaltado.
class MainWindow : public QMainWindow
{
Q_OBJECT
public:
MainWindow(QWidget *parent = nullptr);
public slots:
void about();
void newFile();
void openFile(const QString &path = QString());
private:
void setupEditor();
void setupFileMenu();
void setupHelpMenu();
QTextEdit *editor;
Highlighter *highlighter;
};En este ejemplo declaramos un puntero a una instancia de ` Highlighter `, que más adelante inicializaremos en la función privada ` setupEditor() `.
Implementación de la clase MainWindow
El constructor de la ventana principal es sencillo. Primero configuramos los menús; a continuación, inicializamos el editor y lo convertimos en el widget central de la aplicación. Por último, establecemos el título de la ventana principal.
MainWindow::MainWindow(QWidget *parent)
: QMainWindow(parent)
{
setupFileMenu();
setupHelpMenu();
setupEditor();
setCentralWidget(editor);
setWindowTitle(tr("Syntax Highlighter"));
}Inicializamos e instalamos el objeto ` Highlighter ` en la función privada de conveniencia `setupEditor()`:
void MainWindow::setupEditor()
{
QFont font;
font.setFamily("Courier");
font.setFixedPitch(true);
font.setPointSize(10);
editor = new QTextEdit;
editor->setFont(font);
highlighter = new Highlighter(editor->document());
QFile file("mainwindow.h");
if (file.open(QFile::ReadOnly | QFile::Text))
editor->setPlainText(file.readAll());
}Primero creamos la fuente que queremos utilizar en el editor; a continuación, creamos el propio editor, que es una instancia de la clase ` QTextEdit `. Antes de inicializar el editor con el archivo de definición de la clase ` MainWindow `, creamos una instancia de ` Highlighter ` pasando el documento del editor como argumento. Este es el documento al que se aplicará el resaltado. Y ya está.
Un objeto ` QSyntaxHighlighter ` solo puede instalarse en un documento a la vez, pero puedes reinstalar fácilmente el resaltador en otro documento utilizando la función ` QSyntaxHighlighter::setDocument()`. La clase ` QSyntaxHighlighter ` también proporciona la función ` document()`, que devuelve el documento actualmente configurado.
© 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.