En esta página

QLocalSocket Class

La clase QLocalSocket proporciona un socket local. Más información...

Encabezado: #include <QLocalSocket>
CMake: find_package(Qt6 REQUIRED COMPONENTS Network)
target_link_libraries(mytarget PRIVATE Qt6::Network)
qmake: QT += network
Heredado de: QIODevice

Tipos públicos

enum LocalSocketError { ConnectionRefusedError, PeerClosedError, ServerNotFoundError, SocketAccessError, SocketResourceError, …, UnknownSocketError }
enum LocalSocketState { UnconnectedState, ConnectingState, ConnectedState, ClosingState }
(since 6.2) enum SocketOption { NoOptions, AbstractNamespaceOption }
flags SocketOptions

Propiedades

Funciones públicas

QLocalSocket(QObject *parent = nullptr)
virtual ~QLocalSocket()
void abort()
QBindable<QLocalSocket::SocketOptions> bindableSocketOptions()
void connectToServer(QIODeviceBase::OpenMode openMode = ReadWrite)
void connectToServer(const QString &name, QIODeviceBase::OpenMode openMode = ReadWrite)
void disconnectFromServer()
QLocalSocket::LocalSocketError error() const
bool flush()
QString fullServerName() const
bool isValid() const
qint64 readBufferSize() const
QString serverName() const
void setReadBufferSize(qint64 size)
void setServerName(const QString &name)
bool setSocketDescriptor(qintptr socketDescriptor, QLocalSocket::LocalSocketState socketState = ConnectedState, QIODeviceBase::OpenMode openMode = ReadWrite)
void setSocketOptions(QLocalSocket::SocketOptions option)
qintptr socketDescriptor() const
QLocalSocket::SocketOptions socketOptions() const
QLocalSocket::LocalSocketState state() const
bool waitForConnected(int msecs = 30000)
bool waitForDisconnected(int msecs = 30000)

Funciones públicas reimplementadas

virtual qint64 bytesAvailable() const override
virtual qint64 bytesToWrite() const override
virtual bool canReadLine() const override
virtual void close() override
virtual bool isSequential() const override
virtual bool open(QIODeviceBase::OpenMode openMode = ReadWrite) override
virtual bool waitForBytesWritten(int msecs = 30000) override
virtual bool waitForReadyRead(int msecs = 30000) override

Señales

void connected()
void disconnected()
void errorOccurred(QLocalSocket::LocalSocketError socketError)
void stateChanged(QLocalSocket::LocalSocketState socketState)

Funciones protegidas reimplementadas

virtual qint64 readData(char *data, qint64 c) override
virtual qint64 readLineData(char *data, qint64 maxSize) override
virtual qint64 skipData(qint64 maxSize) override
virtual qint64 writeData(const char *data, qint64 c) override

Descripción detallada

En Windows se trata de una tubería con nombre y en Unix, de un socket de dominio local.

Si se produce un error, ` error()` devuelve el tipo de error, y se puede llamar a ` errorString()` para obtener una descripción legible por el usuario de lo que ha ocurrido.

Aunque QLocalSocket está diseñado para utilizarse con un bucle de eventos, es posible utilizarlo sin él. En ese caso, debes utilizar waitForConnected(), waitForReadyRead(), waitForBytesWritten() y waitForDisconnected(), que bloquea la ejecución hasta que la operación se complete o expire el tiempo de espera.

Véase también QLocalServer.

Documentación sobre tipos de miembros

enum QLocalSocket::LocalSocketError

La enumeración `LocalServerError` representa los errores que pueden producirse. El error más reciente se puede obtener mediante una llamada a ` QLocalSocket::error()`.

ConstanteValorDescripción
QLocalSocket::ConnectionRefusedErrorQAbstractSocket::ConnectionRefusedErrorLa conexión fue rechazada por el par (o se agotó el tiempo de espera).
QLocalSocket::PeerClosedErrorQAbstractSocket::RemoteHostClosedErrorEl socket remoto cerró la conexión. Ten en cuenta que el socket del cliente (es decir, este socket) se cerrará una vez que se haya enviado la notificación de cierre remoto.
QLocalSocket::ServerNotFoundErrorQAbstractSocket::HostNotFoundErrorNo se ha encontrado el nombre del socket local.
QLocalSocket::SocketAccessErrorQAbstractSocket::SocketAccessErrorLa operación del socket falló porque la aplicación carecía de los privilegios necesarios.
QLocalSocket::SocketResourceErrorQAbstractSocket::SocketResourceErrorEl sistema local se quedó sin recursos (por ejemplo, demasiados sockets).
QLocalSocket::SocketTimeoutErrorQAbstractSocket::SocketTimeoutErrorLa operación del socket superó el tiempo de espera.
QLocalSocket::DatagramTooLargeErrorQAbstractSocket::DatagramTooLargeErrorEl datagrama superaba el límite del sistema operativo (que puede ser tan bajo como 8192 bytes).
QLocalSocket::ConnectionErrorQAbstractSocket::NetworkErrorSe ha producido un error en la conexión.
QLocalSocket::UnsupportedSocketOperationErrorQAbstractSocket::UnsupportedSocketOperationErrorEl sistema operativo local no admite la operación de socket solicitada.
QLocalSocket::OperationErrorQAbstractSocket::OperationErrorSe intentó realizar una operación mientras el socket se encontraba en un estado que no lo permitía.
QLocalSocket::UnknownSocketErrorQAbstractSocket::UnknownSocketErrorSe ha producido un error no identificado.

enum QLocalSocket::LocalSocketState

Esta enumeración describe los diferentes estados en los que puede encontrarse un socket.

ConstanteValorDescripción
QLocalSocket::UnconnectedStateQAbstractSocket::UnconnectedStateEl socket no está conectado.
QLocalSocket::ConnectingStateQAbstractSocket::ConnectingStateEl socket ha iniciado el establecimiento de una conexión.
QLocalSocket::ConnectedStateQAbstractSocket::ConnectedStateSe ha establecido una conexión.
QLocalSocket::ClosingStateQAbstractSocket::ClosingStateEl socket está a punto de cerrarse (puede que aún haya datos pendientes de escribir).

Véase también QLocalSocket::state().

[since 6.2] enum QLocalSocket::SocketOption
flags QLocalSocket::SocketOptions

Esta enumeración describe las posibles opciones que se pueden utilizar para conectarse a un servidor. Actualmente, en Linux y Android se utiliza para especificar la conexión a un servidor que escucha en un socket vinculado a una dirección abstracta.

ConstanteValorDescripción
QLocalSocket::NoOptions0x00No se ha establecido ninguna opción.
QLocalSocket::AbstractNamespaceOption0x01El socket intentará conectarse a una dirección abstracta. Este indicador es específico de Linux y Android. En otras plataformas se ignora.

Esta enumeración se introdujo en Qt 6.2.

El tipo `SocketOptions` es una definición de tipo (`typedef`) para ` QFlags<SocketOption>`. Almacena una combinación OR de valores de `SocketOption`.

Véase también socketOptions.

Documentación de la propiedad

[bindable, since 6.2] socketOptions : SocketOptions

Nota: Esta propiedad admite enlaces de tipo « QProperty ».

Esta propiedad contiene las opciones del socket.

Las opciones deben configurarse mientras el socket se encuentra en estado « UnconnectedState ».

Esta enumeración se introdujo en Qt 6.2.

Funciones de acceso:

QLocalSocket::SocketOptions socketOptions() const
void setSocketOptions(QLocalSocket::SocketOptions option)

Véase también ` connectToServer()`.

Documentación de las funciones miembro

QLocalSocket::QLocalSocket(QObject *parent = nullptr)

Crea un nuevo socket local. El argumento « parent » se pasa al constructor de « QObject ».

[virtual noexcept] QLocalSocket::~QLocalSocket()

Elimina el socket y, si es necesario, cierra la conexión.

void QLocalSocket::abort()

Interrumpe la conexión actual y restablece el socket. A diferencia de ` disconnectFromServer()`, esta función cierra inmediatamente el socket, borrando cualquier dato pendiente en el búfer de escritura.

Véanse también disconnectFromServer() y close().

[override virtual] qint64 QLocalSocket::bytesAvailable() const

Reimplementa: ` QIODevice::bytesAvailable()` const.

[override virtual] qint64 QLocalSocket::bytesToWrite() const

Reimplementa: ` QIODevice::bytesToWrite()` const.

[override virtual] bool QLocalSocket::canReadLine() const

Reimplementa: QIODevice::canReadLine() const.

[override virtual] void QLocalSocket::close()

Reimplementa: ` QIODevice::close()`.

Cierra el dispositivo de E/S del socket y llama a disconnectFromServer() para cerrar la conexión del socket.

Consulte QIODevice::close() para obtener una descripción de las acciones que se producen al cerrar un dispositivo de E/S.

Véase también abort().

void QLocalSocket::connectToServer(QIODeviceBase::OpenMode openMode = ReadWrite)

Intenta establecer una conexión con serverName(). Es necesario llamar a setServerName() antes de abrir la conexión. Como alternativa, puedes utilizar connectToServer(const QString &name, OpenMode openMode);

El socket se abre en el openMode especificado y, en primer lugar, entra en ConnectingState. Si se establece una conexión, QLocalSocket entra en ConnectedState y emite connected().

Tras llamar a esta función, el socket puede emitir errorOccurred() para indicar que se ha producido un error.

Véase también state(), serverName() y waitForConnected().

void QLocalSocket::connectToServer(const QString &name, QIODeviceBase::OpenMode openMode = ReadWrite)

Establece el servidor name e intenta conectarse a él.

El socket se abre en el openMode especificado y, en primer lugar, accede a ConnectingState. Si se establece una conexión, QLocalSocket accede a ConnectedState y emite connected().

Tras llamar a esta función, el socket puede emitir errorOccurred() para indicar que se ha producido un error.

Se trata de una función sobrecargada.

Véase también state(), serverName() y waitForConnected().

[signal] void QLocalSocket::connected()

Esta señal se emite después de que se haya llamado a connectToServer() y se haya establecido correctamente una conexión.

Véanse también connectToServer() y disconnected().

void QLocalSocket::disconnectFromServer()

Intenta cerrar el socket. Si hay datos pendientes de escribir, « QLocalSocket » entrará en « ClosingState » y esperará hasta que se hayan escrito todos los datos. Finalmente, entrará en « UnconnectedState » y emitirá la señal « disconnected()».

Véase también ` connectToServer()`.

[signal] void QLocalSocket::disconnected()

Esta señal se emite cuando se ha desconectado el socket.

Véanse también connectToServer(), disconnectFromServer(), abort() y connected().

QLocalSocket::LocalSocketError QLocalSocket::error() const

Devuelve el tipo de error que se ha producido más recientemente.

Véase también state() y errorString().

[signal] void QLocalSocket::errorOccurred(QLocalSocket::LocalSocketError socketError)

Esta señal se emite cuando se produce un error. El parámetro « socketError » describe el tipo de error que se ha producido.

Véanse también error() y errorString().

bool QLocalSocket::flush()

Esta función escribe todo lo que sea posible desde el búfer de escritura interno al socket, sin bloquearse. Si se han escrito datos, esta función devuelve ` true`; en caso contrario, devuelve `false`.

Llama a esta función si necesitas que ` QLocalSocket ` comience a enviar los datos almacenados en el búfer de inmediato. El número de bytes escritos con éxito depende del sistema operativo. En la mayoría de los casos, no es necesario llamar a esta función, ya que ` QLocalSocket ` comenzará a enviar datos automáticamente una vez que el control vuelva al bucle de eventos. Si no hay un bucle de eventos, llama en su lugar a ` waitForBytesWritten()`.

Véase también write() y waitForBytesWritten().

QString QLocalSocket::fullServerName() const

Devuelve la ruta del servidor al que está conectado el socket.

Nota: El valor devuelto por esta función depende de la plataforma.

Véase también connectToServer() y serverName().

[override virtual] bool QLocalSocket::isSequential() const

Reimplementa: ` QIODevice::isSequential()` const.

bool QLocalSocket::isValid() const

Devuelve « true » si el socket es válido y está listo para su uso; en caso contrario, devuelve « false ».

Nota: El estado del socket debe ser ConnectedState antes de que se pueda leer o escribir.

Véase también state() y connectToServer().

[override virtual] bool QLocalSocket::open(QIODeviceBase::OpenMode openMode = ReadWrite)

Reimplementa: ` QIODevice::open` (modo `QIODeviceBase::OpenMode`).

Equivalente a connectToServer(modo OpenMode). El socket se abre en el openMode especificado al servidor definido por setServerName().

Tenga en cuenta que, a diferencia de lo que ocurre en la mayoría de las demás subclases de QIODevice, es posible que open() no abra el dispositivo directamente. La función devuelve false si el socket ya estaba conectado o si no se ha definido el servidor al que conectarse, y true en cualquier otro caso. Se emitirán las señales connected() o errorOccurred() una vez que el dispositivo esté realmente abierto (o si la conexión ha fallado).

Consulte connectToServer() para obtener más detalles.

qint64 QLocalSocket::readBufferSize() const

Devuelve el tamaño del búfer de lectura interno. Esto limita la cantidad de datos que el cliente puede recibir antes de llamar a read() o readAll(). Un tamaño de búfer de lectura de 0 (el valor por defecto) significa que el búfer no tiene límite de tamaño, lo que garantiza que no se pierdan datos.

Véanse también setReadBufferSize() y read().

[override virtual protected] qint64 QLocalSocket::readData(char *data, qint64 c)

Reimplementa: QIODevice::readData(char *data, qint64 maxSize).

[override virtual protected] qint64 QLocalSocket::readLineData(char *data, qint64 maxSize)

Reimplementa: QIODevice::readLineData(char *data, qint64 maxSize).

QString QLocalSocket::serverName() const

Devuelve el nombre del par tal y como se especifica en ` setServerName()`; o bien, un ` QString ` vacío si no se ha llamado a ` setServerName()` o si ` connectToServer()` ha fallado.

Véanse también setServerName(), connectToServer() y fullServerName().

void QLocalSocket::setReadBufferSize(qint64 size)

Establece el tamaño del búfer de lectura interno de ` QLocalSocket` en size bytes.

Si el tamaño del búfer se limita a un valor determinado, QLocalSocket no almacenará en el búfer más datos que ese tamaño. Excepcionalmente, un tamaño de búfer igual a 0 significa que el búfer de lectura es ilimitado y se almacenan en él todos los datos entrantes. Este es el valor por defecto.

Esta opción resulta útil si solo se leen los datos en determinados momentos (por ejemplo, en una aplicación de transmisión en tiempo real) o si se desea proteger el socket contra la recepción de un volumen excesivo de datos, lo que podría acabar provocando que la aplicación se quede sin memoria.

Véase también readBufferSize() y read().

void QLocalSocket::setServerName(const QString &name)

Establece el ` name ` del par al que se va a conectar. En Windows, «name» es el nombre de una tubería con nombre; en Unix, «name» es el nombre de un socket de dominio local.

Esta función debe llamarse cuando el socket no esté conectado.

Véase también serverName().

bool QLocalSocket::setSocketDescriptor(qintptr socketDescriptor, QLocalSocket::LocalSocketState socketState = ConnectedState, QIODeviceBase::OpenMode openMode = ReadWrite)

Inicializa QLocalSocket con el descriptor de socket nativo socketDescriptor. Devuelve true si socketDescriptor se acepta como un descriptor de socket válido; en caso contrario, devuelve false. El socket se abre en el modo especificado por openMode y pasa al estado de socket especificado por socketState.

Nota: Noes posible inicializar dos sockets locales con el mismo descriptor de socket nativo.

Véase también socketDescriptor(), state() y openMode().

[override virtual protected] qint64 QLocalSocket::skipData(qint64 maxSize)

Reimplementa: QIODevice::skipData(qint64 maxSize).

qintptr QLocalSocket::socketDescriptor() const

Devuelve el descriptor de socket nativo del objeto ` QLocalSocket ` si está disponible; en caso contrario, devuelve -1.

El descriptor de socket no está disponible cuando QLocalSocket se encuentra en UnconnectedState. El tipo del descriptor depende de la plataforma:

Véase también setSocketDescriptor().

QLocalSocket::LocalSocketState QLocalSocket::state() const

Devuelve el estado del socket.

Véase también error().

[signal] void QLocalSocket::stateChanged(QLocalSocket::LocalSocketState socketState)

Esta señal se emite cada vez que cambia el estado de QLocalSocket. El parámetro socketState indica el nuevo estado.

Véase también state().

[override virtual] bool QLocalSocket::waitForBytesWritten(int msecs = 30000)

Reimplementa: ` QIODevice::waitForBytesWritten` (`int msecs`).

bool QLocalSocket::waitForConnected(int msecs = 30000)

Espera hasta que el socket se conecte, durante un máximo de msecs milisegundos. Si se ha establecido la conexión, esta función devuelve true; en caso contrario, devuelve false. En el caso de que devuelva false, se puede llamar a error() para determinar la causa del error.

El siguiente ejemplo espera hasta un segundo a que se establezca una conexión:

socket->connectToServer("market");
if (socket->waitForConnected(1000))
    qDebug("Connected!");

Si msecs es -1, esta función no agotará el tiempo de espera.

Véanse también connectToServer() y connected().

bool QLocalSocket::waitForDisconnected(int msecs = 30000)

Espera a que el socket se haya desconectado, hasta un máximo de msecs milisegundos. Si la conexión se ha desconectado correctamente, esta función devuelve true; en caso contrario, devuelve false (si se ha agotado el tiempo de espera de la operación, si se ha producido un error o si este QLocalSocket ya está desconectado). En el caso de que devuelva false, puedes llamar a error() para determinar la causa del error.

El siguiente ejemplo espera hasta un segundo a que se cierre una conexión:

socket->disconnectFromServer();
if (socket->state()== QLocalSocket::UnconnectedState
    || socket->waitForDisconnected(1000)) {
    qDebug("Disconnected!");
}

Si msecs es -1, esta función no agotará el tiempo de espera.

Véase también disconnectFromServer() y close().

[override virtual] bool QLocalSocket::waitForReadyRead(int msecs = 30000)

Reimplementa: QIODevice::waitForReadyRead(int msecs).

Esta función se bloquea hasta que haya datos disponibles para su lectura y se haya emitido la señal « readyRead()». La función agotará el tiempo de espera tras « msecs » milisegundos; el tiempo de espera por defecto es de 30 000 milisegundos.

La función devuelve « true » si hay datos disponibles para su lectura; en caso contrario, devuelve « false » (si se ha producido un error o se ha agotado el tiempo de espera de la operación).

Véase también waitForBytesWritten().

[override virtual protected] qint64 QLocalSocket::writeData(const char *data, qint64 c)

Reimplementa: QIODevice::writeData(const char *data, qint64 maxSize).

© 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.