C++ QTcpSocket和多个客户端（信号问题）

我正在开发一个服务器，它可以响应来自客户端的多个连接。但我有一个问题，我没有找到任何解决办法。 我为qtcsocket创建了一个类（TcpSocket），用于分离每个连接的信号和插槽

但是我的服务器没有识别这个类的信号，它寻找的是qtcsocket，而不是TcpSocket

我会把代码贴出来，也许你能更好地理解，因为我的英语不好

tcpsocket.h

#ifndef TCPSOCKET_H
#define TCPSOCKET_H

#include <QObject>
#include <QtNetwork>

class TcpSocket: public QTcpSocket
{
    Q_OBJECT
    QTcpSocket *Socket;
public:
    TcpSocket (QTcpSocket *);
    virtual ~TcpSocket();

public slots:
    void slotReadyRead();
    void slotConnected();
    void slotDisconnected();

signals:
    void dataReady (TcpSocket *sckt);
    void newConnection(TcpSocket *sckt);
    void lostConnection(TcpSocket *sckt);
};


#endif // TCPSOCKET_H

#ifndef SERVER_H
#define SERVER_H

#include <QMainWindow>
#include <QTcpServer>
#include <QTcpSocket>
#include "custom/player.h"
#include "events.h"
#include "socketmanager.h"
#include "tcpsocket.h"

#include <QMessageBox>

namespace Ui {
class Server;
}

class Server : public QMainWindow
{
    Q_OBJECT


public:
    explicit Server(QWidget *parent = 0);
    int max_connections;
    ~Server();

private slots:
    ...
    void client_Disconnected(TcpSocket *socket);
    void client_SendedBytes(qint64 bytes);
    void client_GetBytes(TcpSocket* socket);
    ...

private:
    Ui::Server *ui;
    QTcpServer *server;
    QList<TcpSocket *> client;
    ...

};

#endif // SERVER_H

server.h

#ifndef TCPSOCKET_H
#define TCPSOCKET_H

#include <QObject>
#include <QtNetwork>

class TcpSocket: public QTcpSocket
{
    Q_OBJECT
    QTcpSocket *Socket;
public:
    TcpSocket (QTcpSocket *);
    virtual ~TcpSocket();

public slots:
    void slotReadyRead();
    void slotConnected();
    void slotDisconnected();

signals:
    void dataReady (TcpSocket *sckt);
    void newConnection(TcpSocket *sckt);
    void lostConnection(TcpSocket *sckt);
};


#endif // TCPSOCKET_H

#ifndef SERVER_H
#define SERVER_H

#include <QMainWindow>
#include <QTcpServer>
#include <QTcpSocket>
#include "custom/player.h"
#include "events.h"
#include "socketmanager.h"
#include "tcpsocket.h"

#include <QMessageBox>

namespace Ui {
class Server;
}

class Server : public QMainWindow
{
    Q_OBJECT


public:
    explicit Server(QWidget *parent = 0);
    int max_connections;
    ~Server();

private slots:
    ...
    void client_Disconnected(TcpSocket *socket);
    void client_SendedBytes(qint64 bytes);
    void client_GetBytes(TcpSocket* socket);
    ...

private:
    Ui::Server *ui;
    QTcpServer *server;
    QList<TcpSocket *> client;
    ...

};

#endif // SERVER_H

#ifndef服务器
#定义服务器
#包括
#包括
#包括
#包括“custom/player.h”
#包括“events.h”
#包括“socketmanager.h”
#包括“tcpsocket.h”
#包括
名称空间用户界面{
类服务器；
}
类服务器：公共QMainWindow
{
Q_对象
公众：
显式服务器（QWidget*parent=0）；
int max_连接；
~Server（）；
专用插槽：
...
无效客户端_断开连接（TcpSocket*套接字）；
无效客户端发送字节（qint64字节）；
无效客户端字节（TcpSocket*socket）；
...
私人：
Ui:：Server*Ui；
qtcserver*服务器；
QList客户端；
...
};
#endif//SERVER\u H

server.cpp

#include "tcpsocket.h"

TcpSocket::TcpSocket(QTcpSocket * socket)
    : Socket (socket)
{
    connect(Socket, SIGNAL(readyRead()), this, SLOT (slotReadyRead()));
    connect(Socket, SIGNAL(connected()), this, SLOT(slotConnected()));
    connect(Socket, SIGNAL(disconnected()), this, SLOT(slotDisconnected()));
}

TcpSocket::~TcpSocket()
{

}

void TcpSocket::slotReadyRead()
{
    emit dataReady(this);
}

void TcpSocket::slotConnected()
{
    emit newConnection(this);
}

void TcpSocket::slotDisconnected()
{
    emit lostConnection(this);
}

int j; // connection count
void Server::server_Connected()
{
    client.insert(j, (TcpSocket*)server->nextPendingConnection());
    TcpSocket *sckt = client[j];
    // error:
    connect(sckt, SIGNAL(newConnection(TcpSocket*)), this, SLOT(client_GetBytes(TcpSocket*)));
    connect(sckt, SIGNAL(lostConnection(TcpSocket*)), this, SLOT(client_Disconnected(TcpSocket*)));

    QByteArray block;
    QTextStream out(&block, QIODevice::WriteOnly);
    out << "accepted";

    ui->log->append(QString("Host connected: %1, index %2").arg(sckt->localAddress().toString()).arg(j));

    std::string stdString = "accepted";
    QByteArray byteArray(stdString.c_str(), stdString.length());
    qint64 len = sckt->write(byteArray);
    if(len != byteArray.size())
        ui->log->append("Error!");
    sckt->flush();

    j++;
}

void Server::client_Disconnected(TcpSocket *socket)
{
...
}

void Server::client_GetBytes(TcpSocket *socket)
{
...
}

int j；//连接计数
无效服务器：：服务器已连接（）
{
insert（j，（TcpSocket*）server->nextPendingConnection（）；
TcpSocket*sckt=client[j]；
//错误：
连接（sckt，信号（newConnection（TcpSocket*）），这个，插槽（client_GetBytes（TcpSocket*））；
连接（sckt，信号（断开连接（TcpSocket*）），此插槽（客户端已断开连接（TcpSocket*））；
QByteArray区块；
QTextStream-out（块，QIODevice:：WriteOnly）（&block）；
out log->append（QString（“已连接的主机：%1，索引%2”）.arg（sckt->localAddress（）.toString（））.arg（j））；
std:：string stdString=“已接受”；
QByteArray byteArray（stdString.c_str（），stdString.length（））；
qint64 len=sckt->write（byteArray）；
if（len！=byteArray.size（））
用户界面->日志->附加（“错误！”）；
sckt->flush（）；
j++；
}
无效服务器：：客户端已断开连接（TcpSocket*套接字）
{
...
}
无效服务器：：客户端\u GetBytes（TcpSocket*套接字）
{
...
}

错误：

QObject:：connect:在..\SOLEditorServer\server.cpp:45中没有这样的信号QTcpSocket:：newConnection（TcpSocket*） QObject:：connect：（接收器名称：“服务器”）

QObject:：connect:在..\SOLEditorServer\server.cpp:46中没有这样的信号QTcpSocket:：lostConnection（TcpSocket*） QObject:：connect：（接收器名称：“服务器”）

还有完整代码（服务器）

#包括“server.h”
#包括“ui_server.h”
#包括
服务器：：服务器（QWidget*父项）：
QMainWindow（父级），
ui（新ui:：服务器）
{
最大连接数=20；
SM=新的SocketManager（）；
用户界面->设置用户界面（此）；
服务器=新的QTcpServer（此）；
连接（服务器，信号（acceptError（QAbstractSocket:：SocketError）），此，插槽（服务器错误（））；
连接（服务器，信号（newConnection（）），此，插槽（服务器已连接（））；
事件=新事件（用户界面->日志）；
setWindowFlags（Qt:：WindowCloseButtonHint）；
}
服务器：：~Server（）
{
删除用户界面；
}
无效服务器：：在按钮上单击（）
{
QHostAddress主机；
setAddress（ui->txt_ip->text（））；
服务器->监听（主机，用户界面->txt_端口->值（））；
用户界面->日志->附加（“已连接！”）；
}
无效服务器：：服务器错误（）
{
用户界面->日志->附加（服务器->错误字符串（））；
}
int j；
无效服务器：：服务器已连接（）
{
insert（j，（TcpSocket*）server->nextPendingConnection（）；
TcpSocket*sckt=client[j]；
连接（sckt，信号（newConnection（TcpSocket*）），这个，插槽（client_GetBytes（TcpSocket*））；
连接（sckt，信号（断开连接（TcpSocket*）），此插槽（客户端已断开连接（TcpSocket*））；
QByteArray区块；
QTextStream-out（块，QIODevice:：WriteOnly）（&block）；
out log->append（QString（“已连接的主机：%1，索引%2”）.arg（sckt->localAddress（）.toString（））.arg（j））；
std:：string stdString=“已接受”；
QByteArray byteArray（stdString.c_str（），stdString.length（））；
qint64 len=sckt->write（byteArray）；
if（len！=byteArray.size（））
用户界面->日志->附加（“错误！”）；
sckt->flush（）；
j++；
}
无效服务器：：客户端已断开连接（TcpSocket*套接字）
{
ui->log->append（QString（“Desconectado（%1）”）.arg（socket->localAddress（）.toString（））；
client.removeAt（client.indexOf（socket））；
}
无效服务器：：客户端发送字节（qint64字节）
{
QString dataxD=QString:：number（字节）；
ui->log->append（QString（“%1字节”）.arg（dataxD））；
}
无效服务器：：客户端\u GetBytes（TcpSocket*套接字）
{
QByteArray缓冲区；
resize（socket->bytesavable（））；
套接字->读取（buffer.data（），buffer.size（））；
QString数据（缓冲区）；
if（data.startsWith（“寄存器”））
{
接收的QString=data.split（“寄存器”）[1]；
用户界面->日志->追加（已接收）；
QString user=received.split（“：”[0]；
QString key=received.split（“：”[1]；
playerList.append（用户）；
playerKey.append（key）；
事件->事件新玩家（用户）；
SM->sendpacketoall（客户端，QString（“问候%1”）.arg（用户））；
}else if（data.startsWith（“CHAT（“））
{
QString UserData=data.split（“CHAT（“）[1]。split（“）”[0]；
如果（！checkUser（UserData））
{
ui->log->append（“没有有效哈希的用户名！”）；
返回；
}
QString User=getUsernameFromData（UserData）；
QString Message=data.split（QString（“聊天（%1）”）.arg（UserData））[1]；
事件->eventNewChatmessage（消息，用户）；
SM->sendpacketoall（客户端，QString（“聊天（%1）%2”）.arg（用户）.arg（消息））；
}
}
bool服务器：：checkUser（qstringusernamedata）
{
如果（！usernamedata.contains（“：”）
返回false；
QString username=usernamedata.split（“：”[0]；
QString key=usernamedata.split（“：”[1]；
如果（！playerList.contains（username）| |！playerKey.contains（key））
返回false；
int playerIndex=playerList.indexOf（用户名）；
QString hashFromList=playerKey[playerIndex]；
if（hashFromList！=键）
class TcpSocket: public QTcpSocket // old
class TcpSocket: public QObject // new

// old
void dataReady (TcpSocket *sckt);
void newConnection(TcpSocket *sckt);
void lostConnection(TcpSocket *sckt);

// new
void dataReady(QTcpSocket *sckt);
void newConnection(QTcpSocket *sckt);
void lostConnection(QTcpSocket *sckt);

// old
TcpSocket::TcpSocket(QTcpSocket * socket)
    : Socket (socket)
{
    connect(Socket, SIGNAL(readyRead()), this, SLOT (slotReadyRead()));
    connect(Socket, SIGNAL(connected()), this, SLOT(slotConnected()));
    connect(Socket, SIGNAL(disconnected()), this, SLOT(slotDisconnected()));
}

// new
TcpSocket::TcpSocket (QTcpSocket * socket)
    : Socket (socket)
{
    this->sock = socket;
    connect(socket, SIGNAL(readyRead()), this, SLOT (slotReadyRead()));
    connect(socket, SIGNAL(connected()), this, SLOT(slotConnected()));
    connect(socket, SIGNAL(disconnected()), this, SLOT(slotDisconnected()));
}

// old
void TcpSocket::slotReadyRead()
{
    emit dataReady(this);
}

void TcpSocket::slotConnected()
{
    emit newConnection(this);
}

void TcpSocket::slotDisconnected()
{
    emit lostConnection(this);
}

// new
void TcpSocket::slotReadyRead()
{
    emit dataReady(this->sock);
}

void TcpSocket::slotConnected()
{
    emit newConnection(this->sock);
}

void TcpSocket::slotDisconnected()
{
    emit lostConnection(this->sock);
}

// old
public:
    TcpSocket (QTcpSocket *);
    virtual ~TcpSocket();

// new
public:
    TcpSocket (QTcpSocket *);
    QTcpSocket *sock;

QTcpSocket *socket = (your QTcpSocket);
TcpSocket *tcpSocket = new TcpSocket(socket);
connect(tcpSocket, SIGNAL(dataReady(QTcpSocket*)), this, SLOT(your_slot(QTcpSocket*)));