用qt写一段socket代理层的代码实现两个上位机同时连接两个下位机，上位机会向下位机发送命令，两个下位机的数据呈现在上位机上

好的，我理解了你的问题。由于你提到了Qt，我假设你想使用Qt实现这个代理层。因此，我将提供一个使用Qt中的Qt Network模块实现的简单代码示例。

在这个示例中，我们将使用一个TcpServer和两个TcpSocket来建立连接。我们将创建一个名为ProxyServer的类，它将负责处理来自上位机和下位机的连接并转发数据。

以下是示例代码：

#include <QtNetwork>

class ProxyServer : public QObject
{
    Q_OBJECT

public:
    ProxyServer(QObject *parent = nullptr)
        : QObject(parent)
    {
        // 创建TcpServer并监听端口
        server1 = new QTcpServer(this);
        server1->listen(QHostAddress::LocalHost, 1234);
        connect(server1, &QTcpServer::newConnection, this, &ProxyServer::onNewConnection1);

        server2 = new QTcpServer(this);
        server2->listen(QHostAddress::LocalHost, 5678);
        connect(server2, &QTcpServer::newConnection, this, &ProxyServer::onNewConnection2);
    }

private slots:
    void onNewConnection1()
    {
        // 处理上位机连接
        QTcpSocket *socket = server1->nextPendingConnection();
        connect(socket, &QTcpSocket::readyRead, this, &ProxyServer::onReadyRead1);
        connect(socket, &QTcpSocket::disconnected, socket, &QTcpSocket::deleteLater);

        // 连接第一个下位机
        socket1 = new QTcpSocket(this);
        socket1->connectToHost(QHostAddress::LocalHost, 1111);
        connect(socket1, &QTcpSocket::connected, this, &ProxyServer::onSocket1Connected);
        connect(socket1, &QTcpSocket::readyRead, this, &ProxyServer::onSocket1ReadyRead);
        connect(socket1, &QTcpSocket::disconnected, this, &ProxyServer::onSocket1Disconnected);
    }

    void onNewConnection2()
    {
        // 处理上位机连接
        QTcpSocket *socket = server2->nextPendingConnection();
        connect(socket, &QTcpSocket::readyRead, this, &ProxyServer::onReadyRead2);
        connect(socket, &QTcpSocket::disconnected, socket, &QTcpSocket::deleteLater);

        // 连接第二个下位机
        socket2 = new QTcpSocket(this);
        socket2->connectToHost(QHostAddress::LocalHost, 2222);
        connect(socket2, &QTcpSocket::connected, this, &ProxyServer::onSocket2Connected);
        connect(socket2, &QTcpSocket::readyRead, this, &ProxyServer::onSocket2ReadyRead);
        connect(socket2, &QTcpSocket::disconnected, this, &ProxyServer::onSocket2Disconnected);
    }

    void onReadyRead1()
    {
        // 从上位机读取数据，并转发到第一个下位机
        QTcpSocket *socket = qobject_cast<QTcpSocket *>(sender());
        QByteArray data = socket->readAll();
        socket1->write(data);
    }

    void onReadyRead2()
    {
        // 从上位机读取数据，并转发到第二个下位机
        QTcpSocket *socket = qobject_cast<QTcpSocket *>(sender());
        QByteArray data = socket->readAll();
        socket2->write(data);
    }

    void onSocket1Connected()
    {
        qDebug() << "Socket1 connected";
    }

    void onSocket1ReadyRead()
    {
        // 从第一个下位机读取数据，并转发到上位机
        QByteArray data = socket1->readAll();
        emit dataReceived1(data);
    }

    void onSocket1Disconnected()
    {
        qDebug() << "Socket1 disconnected";
    }

    void onSocket2Connected()
    {
        qDebug() << "Socket2 connected";
    }

    void onSocket2ReadyRead()
    {
        // 从第二个下位机读取数据，并转发到上位机
        QByteArray data = socket2->readAll();
        emit dataReceived2(data);
    }

    void onSocket2Disconnected()
    {
        qDebug() << "Socket2 disconnected";
    }

signals:
    void dataReceived1(const QByteArray &data);
    void dataReceived2(const QByteArray &data);

private:
    QTcpServer *server1;
    QTcpServer *server2;
    QTcpSocket *socket1;
    QTcpSocket *socket2;
};

在这个示例中，我们创建了一个名为ProxyServer的类，它继承自QObject。它包含两个TcpServer和两个TcpSocket，一个用于处理来自第一个上位机的连接，另一个用于处理来自第二个上位机的连接。每个上位机连接都将建立到两个下位机之一，并将数据转发到相应的下位机。

在构造函数中，我们创建了TcpServer并开始侦听连接。每当有一个新的连接时，我们会调用onNewConnection1()或onNewConnection2()方法来处理连接。我们还连接了socket的readyRead()和disconnected()信号，用于在收到数据或断开连接时执行适当的操作。

在onNewConnection1()和onNewConnection2()方法中，我们将创建一个新的TcpSocket并连接到相应的下位机，同时将上位机连接的readyRead()信号连接到onReadyRead1()或onReadyRead2()方法，以便我们可以从上位机读取数据并将其转发到相应的下位机。

在onReadyRead1()和onReadyRead2()方法中，我们将从上位机读取数据，并将其写入到相应的下位机。在onSocket1ReadyRead()和onSocket2ReadyRead()方法中，我们将从相应的下位机读取数据，并发出dataReceived1()或dataReceived2()信号，以便我们可以将数据转发回相应的上位机。

最后，我们可以使用以下代码创建ProxyServer对象：

int main(int argc, char *argv[])
{
    QCoreApplication app(argc, argv);
    ProxyServer server;
    QObject::connect(&server, &ProxyServer::dataReceived1, [] (const QByteArray &data) {
        qDebug() << "Data from socket1: " << data;
    });
    QObject::connect(&server, &ProxyServer::dataReceived2, [] (const QByteArray &data) {
        qDebug() << "Data from socket2: " << data;
    });
    return app.exec();
}

在这个示例中，我们连接了dataReceived1()和dataReceived2()信号，以便我们可以从第一个或第二个下位机接收数据并将其打印到控制台上。

请注意，这只是一个非常简单的示例，仅用于说明如何使用Qt Network模块实现一个简单的代理层。在实际应用中，可能需要添加更多的错误处理和安全性检查。