[QT] Problème de classe

Bonjour a tous , je code actuellement un programme de chat en ligne . j'ai un problème sur la partie serveur du programme , j'ai un classe FenSeveur et une Client , client contient de sinformations sur chaque client connecter(pseudo , socket etc...)

J'ai un problème avec mon code a la compilation il m'indique ca :

https://imageshack.com/

Les codes :

FenServeur.h :

#ifndef HEADER_FENSERVEUR
#define HEADER_FENSERVEUR

#include <QtGui>
#include <QtNetwork>
#include "Client.h"

class FenServeur : public QWidget
{
    Q_OBJECT

    public:
        FenServeur();
        void envoyerATous(const QString &message);

    private slots:
        void nouvelleConnexion();
        void deconnexionClient();
        void envoyerPaquet(QString paquet, QString destinataire);


    private:
        QLabel *lblEtatServeur;
        QPushButton *boutonQuitter;

        QTcpServer *serveur;
        QList<Client *> clients;
        int nombreJoueur;

};

#endif

FenServeur.cpp (une des erreures est marquées lignes 38 )

#include "FenServeur.h"

FenServeur::FenServeur()
{
    // Création et disposition des widgets de la fenêtre
    lblEtatServeur = new QLabel;
    boutonQuitter = new QPushButton(tr("Quitter"));
    connect(boutonQuitter, SIGNAL(clicked()), qApp, SLOT(quit()));

    QVBoxLayout *layout = new QVBoxLayout;
    layout->addWidget(lblEtatServeur);
    layout->addWidget(boutonQuitter);
    setLayout(layout);

    setWindowTitle(tr("NicoChat - Serveur"));

    // Gestion du serveur
    serveur = new QTcpServer(this);
    if (!serveur->listen(QHostAddress::Any, 50777)) // Démarrage du serveur sur toutes les IP disponibles et sur le port 50777
    {
        // Si le serveur n'a pas été démarré correctement
        lblEtatServeur->setText(tr("Le serveur n'a pas pu être démarré. Raison :<br />") + serveur->errorString());
    }
    else
    {
        // Si le serveur a été démarré correctement
        lblEtatServeur->setText(tr("Le serveur a été démarré sur le port <strong>") + QString::number(serveur->serverPort()) + tr("</strong>.<br />Des clients peuvent maintenant se connecter."));
        connect(serveur, SIGNAL(newConnection()), this, SLOT(nouvelleConnexion()));
    }

   nombreJoueur = 0;
}

void FenServeur::nouvelleConnexion()
{
    //envoyerATous(tr("<em>Un nouveau client vient de se connecter</em>"));

    Client *nouveauClient = new Client(serveur->nextPendingConnection(), nombreJoueur);
    clients << nouveauClient;

    connect(nouveauClient, SIGNAL(demandeEnvoiePaquet(QString, QString)), this, SLOT(envoyerPaquet(QString, QString)));
    connect(nouveauClient, SIGNAL(deconnecte()), this, SLOT(deconnexionClient()));
    nombreJoueur++;
}

void FenServeur::envoyerPaquet(QString paquet, QString destinataire)
{
    if(destinataire == "all")
    {
        envoyerATous(paquet);
    }
}

void FenServeur::deconnexionClient()
{
    // On détermine quel client se déconnecte
    Client *clientDeconnecte = qobject_cast<Client *>(sender());
    if (clientDeconnecte == 0) // Si par hasard on n'a pas trouvé le client à l'origine du signal, on arrête la méthode
        return;

    envoyerATous(tr("<em><strong>") + clientDeconnecte->getPseudo() + tr("</strong> vient de se déconnecter</em>"));
    int i = 0;
    clients.removeAt(i);
    nombreJoueur = nombreJoueur - 1;
}



void FenServeur::envoyerATous(const QString &message)
{
    for (int i = 0; i < clients.size(); i++)
    {
        clients[i]->envoyerPaquet(message);
    }

}

Client.h :

#ifndef HEADER_CLIENT
#define HEADER_CLIENT

#include <QtNetwork>
#include <QString>

class Client : public QObject
{
    Q_OBJECT

    public:
        Client(QTcpSocket *client = 0, int nombre = 0);
        ~Client();
        bool isConnecte();
        void setPseudo(QString nouveauPseudo);
        void setConnecte(bool co);
        QString getPseudo();
        int getValeure();
        void envoyerPaquet(QString message);

    public slots:
        void deconnexion();
        void slotDeconnecte();

    private slots:
        void donneesRecues();

    signals:
        void demandeEnvoiePaquet(QString paquet, QString destinataire);
        void deconnecte();
        void demandeConnexionCompte(QString pseudo, QString password);
        void messageEnAttente();

    private:
        void gererMessage(QString message, QTcpSocket *client);

    private:
        QTcpSocket *socket;
        QString pseudo;
        bool connecte;
        quint16 tailleMessage;
        int valeure;
};

#endif

Client.cpp :

#include "Client.h"

//Constructeur -- Destructeur
Client::Client(QTcpSocket *client, int nombre) : socket(client), connecte(false), pseudo("") , valeure(nombre)
{
    if(socket == 0)
        socket = new QTcpSocket;

    connect(socket, SIGNAL(readyRead()), this, SLOT(donneesRecues()));
    connect(socket, SIGNAL(disconnect()), this, SLOT(slotDeconnecte()));
}

Client::~Client()
{
    deconnexion();
    socket->deleteLater();
}
//#####################################################################################################

// Fonctions publiques :
bool Client::isConnecte()
{
    return connecte;
}

QString Client::getPseudo()
{
    return pseudo;
}

int Client::getValeure()
{

    return valeure;

}

void Client::setPseudo(QString nouveauPseudo)
{
    pseudo = nouveauPseudo;
}

void Client::setConnecte(bool etat)
{
    connecte = etat;
}

void Client::envoyerPaquet(QString message)
{
    QByteArray paquet;
    QDataStream out(&paquet, QIODevice::WriteOnly);

    out << (quint16) 0;
    out << message;
    out.device()->seek(0);
    out << (quint16) (paquet.size() - sizeof(quint16));

    socket->write(paquet);
}

// ###########################################################################################

// Slots publiques :
void Client::deconnexion()
{
    socket->abort();
    socket->close();
}

void Client::slotDeconnecte()
{
    connecte = false;
    emit deconnecte();
}

//###############################################################################################

// Slots privés :
void Client::donneesRecues()
{
    QTcpSocket *socket = qobject_cast<QTcpSocket *>(sender());
    if (socket == 0)
        return;

    QDataStream in(socket);

    if (tailleMessage == 0)
    {
        if (socket->bytesAvailable() < (int)sizeof(quint16))
             return;

        in >> tailleMessage;
    }

    if (socket->bytesAvailable() < tailleMessage)
        return;

    QString message;
    in >> message;

    tailleMessage = 0;

    gererMessage(message, socket);
}

// #######################################################################################

// Fonctions privés :
void Client::gererMessage(QString message, QTcpSocket *client)
{
     emit messageEnAttente();
}

Voila , merci et bonne journée.