Héritage de classes en c++

Bonjour,
D'après mes connaissances, quand on défini une classe dérivée, son constructeur appelle automatiquement celui de la classe de base. Ce que j'ai fait c'est de définir une classe qui hérite d'une autre, mais quand je l'appelle avec les paramètres du constructeurs de la classe de base le compilateur l'accepte pas et voici l'erreur qu'il me renvoi:

client1.cpp:35: erreur: no matching function for call to ‘Client_TCP2::Client_TCP2(const char [10], int, bool, bool)’
client1.cpp:28: note: candidats sont: Client_TCP2::Client_TCP2()
client1.cpp:28: note:                 Client_TCP2::Client_TCP2(const Client_TCP2&)
make: *** [client1.o] Erreur 1

Mon code est le suivant:

 
#include <iostream>
#include "cogitant/cogitant.h"
#include "cogitant/cs/ccxx.h"
#include "cogitant/cs/client.h"
 
using namespace std;
using namespace cogitant;
using namespace cogitantcs;
 
class Client_TCP2: public Client_TCP
{
 
};
 
int main(int , char* [])
{
try{
    Client_TCP2 client("127.0.0.1", 4246,true,true);   
   }
 
catch (cogitant::Exception const & e)
    {
        cerr << e;
        return 1;
    }
    return 0;
}
 

Et la classe de base est définie ici:

 
// ==============
//   CoGITaNT 5 
// ==============
 
/** \file cs/ccxx.h
 *	Opérations d'entrées sorties utilisant la bibliothèque Common C++ (v1 ou v2).
 *	Déclaration des classes cogitantcs::OperationCSIO_TCP, cogitantcs:OperationCSIO_HTTP, cogitantcs::Server_TCP, cogitantcs::Client_TCP et cogitantcs::Client_HTTP.
 *	\author David Genest.
 */
 
#ifndef CogitantCS_Ccxx_h
#define CogitantCS_Ccxx_h
 
#include <cc++/socket.h>
#include <cc++/url.h>
#include "cogitant/cs/server.h"
#include "cogitant/cs/client.h"
 
namespace cogitantcs {
 
/** \class OperationCSIO_TCP cs/ccxx.h "cogitant/cs/ccxx.h"
 *	Opération simple de lecture et d'écriture sur une socket.
 *	Cette opération n'accepte pas plusieurs connextions simultanées
 *	\warning Requiert l'utilisation de la bibliothèque CommonC++. */
class CGTDLLEXPORT_CS_CCXX OperationCSIO_TCP: public OperationCSIO
{
private:
		/** Nom d'hote du serveur.
		 * 	(utilisé uniquement pour le client) */
		std::string m_server;
		/** Port (en TCP). */
		ost::tpport_t m_port;
		/** Socket de communication. */
		ost::TCPStream * m_tcpstream;
	
public:
		/** Constructeur pour utilisation en serveur.
		 *	\param port Numéro de port d'attente de connexions. */
		OperationCSIO_TCP(ost::tpport_t port = 4246);
		/** Constructeur pour utilisation en client.
		 *	\param host Nom d'hote du serveur.
		 *	\param port Numéro du port du serveur. */
		OperationCSIO_TCP(std::string const & host, ost::tpport_t port=4246);
		
		/** Destructeur. */
		~OperationCSIO_TCP();
 
		/** Ouverture d'une connexion client.
		 *	La connexion est demandée vers le serveur / port précisés au constructeur. */
		void open();
		/** Fermeture d'une connexion client.
		 *	La liaison TCP est coupée. */
		void close();
 
		/** Démarrage de l'écoute (mode serveur). */
		void listen();
		/** Arrêt de l'écoute (mode serveur). */
		void stop();
 
		void receive(cogitant::XmlDocument & doc, iSession & ids);
		void send(cogitant::XmlDocument const & doc, iSession ids=0);
		void send(std::list<std::string> const & txt, iSession ids=0);
};
 
/** \class OperationCSIO_HTTP cs/ccxx.h "cogitant/cs/ccxx.h"
 *	Opération simple de lecture et d'écriture en utilisant le protocole HTTP (POST).
 *	\warning Seules les fonctions de client sont implantées dans cette classe, et il est interdit d'utiliser cette classe dans un serveur, car les méthodes listen() et stop() ne peuvent être utilisées (pour l'instant). */
class CGTDLLEXPORT_CS_CCXX OperationCSIO_HTTP: public OperationCSIO
{
private:
		/** URL. */
		std::string m_url;
		/** Socket de communication. */
		ost::URLStream m_stream;
 
public:
		/** Constructeur pour utilisation en client.
		 *	\param url URL du serveur à contacter. */
		OperationCSIO_HTTP(std::string const & url);
		/** Destructeur. */
		~OperationCSIO_HTTP();
 
		/** Démarrage de l'écoute (mode serveur).
		 *	\warning Méthode non implantée ! */
		void listen();
		/** Arrêt de l'écoute (mode serveur).
		 *	\warning Méthode non implantée ! */
		void stop();
 
		void receive(cogitant::XmlDocument & doc, iSession & ids);
		void send(cogitant::XmlDocument const & doc, iSession ids=0);
		void send(std::list<std::string> const & txt, iSession ids=0);
};
 
/** \class Server_TCP cs/ccxx.h "cogitant/cs/ccxx.h"
 *	Serveur simple qui attend des connexions sur une socket et lit requêtes sur cette socket avant de retourner la réponse par le même moyen.
 *	\sa cogitantcs::OperationCSIO_TCP. */
class CGTDLLEXPORT_CS_CCXX Server_TCP: public Server
{
public:
		/** Constructeur.
		 *	\param port Numéro de port d'attente de connexions. */
		Server_TCP(unsigned int port = 4246);
};
 
/** \class Client_TCP cs/ccxx.h "cogitant/cs/ccxx.h"
 *	Implantation du client en utilisant le protocole TCP.
 *	Dans ce mode, le client reste connecté en permanence au serveur par TCP. 
 *	\sa cogitantcs::OperationCSIO_TCP. */
class CGTDLLEXPORT_CS_CCXX Client_TCP: public Client
{
public:
		/** Constructeur.
		 *	\param host nom d'hote du serveur.
		 *	\param port numéro du port du serveur.
		 *	\param localsupport si \c true le support est local au client, et le serveur n'est jamais interrogé pour obtenir le support. Si \c false il ne faut pas charger un support dans l'environnement associé au client, car le support de l'environnement est celui du serveur.
		 *	\param localobjects si \c true les objets de l'environnement sont locaux, et le serveur n'est jamais interrogé pour obtenir les objets. */
		Client_TCP(std::string const & host, unsigned int port=4246, bool localsupport=false, bool localobjects=false);
};
 
 
/** \class Client_HTTP cs/ccxx.h "cogitant/cs/ccxx.h"
 *	Implantation du client en utilisant le protocole HTTP (POST).
 *	Dans ce mode, le client établit une connexion avec un serveur HTTP à chaque exécution de requête devant être transmise au serveur. Il faut donc que le serveur HTTP contacté rende accessible le serveur CoGITaNT par le biais d'un CGI.
 *	\sa cogitantcs::OperationCSIO_HTTP. */
class CGTDLLEXPORT_CS_CCXX Client_HTTP: public Client
{
public:
		/** Constructeur.
		 *	\param url URL à laquelle le serveur est accessible.
		 *	\param localsupport si \c true le support est local au client, et le serveur n'est jamais interrogé pour obtenir le support. Si \c false il ne faut pas charger un support dans l'environnement associé au client, car le support de l'environnement est celui du serveur.
		 *	\param localobjects si \c true les objets de l'environnement sont locaux, et le serveur n'est jamais interrogé pour obtenir les objets. */
		Client_HTTP(std::string const & url, bool localsupport=false, bool localobjects=false);
};
 
}
#endif
 
 merci