Sujet Précédent Sujet Suivant

Question sur l'héritage

cs_hnouna2007 Messages postés 1 Date d'inscription dimanche 17 décembre 2000 Statut Membre Dernière intervention 26 juillet 2009 - 26 juil. 2009 à 10:50
kwahy Messages postés 1 Date d'inscription dimanche 13 mai 2007 Statut Membre Dernière intervention 11 octobre 2011 - 25 févr. 2011 à 23:39
salut,
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 
#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

2 réponses

Réponse 1 / 2
cptpingu Messages postés 3837 Date d'inscription dimanche 12 décembre 2004 Statut Modérateur Dernière intervention 28 mars 2023 123
26 juil. 2009 à 13:40
C'est normal. Ta classe "Client_TCP2" n'as pas de constructeur autre que celui par défaut.
Les constructeurs ne "s'héritent" pas, même si effectivement ils s'appellent entre eux. Il te faut créer un constructeur dans cette classe qui appelle celui d'au-dessus.
0
Réponse 2 / 2
kwahy Messages postés 1 Date d'inscription dimanche 13 mai 2007 Statut Membre Dernière intervention 11 octobre 2011
25 févr. 2011 à 23:39
Bonjour à vous les pros!!
Je souhaite manipuler des graphes conceptuels avec cogitant que j'avait construit avec cogui du lirmm mais je ne sais pas comment procéder (très débutant) ce que je souhaite c'est de faire des opération sur ces graphes, plus précisément je souhaite implémenter l'algorithme de Chapin et Solnon qui est un algorithme pour avoir un plus grand sous graphe commun:

fonction Glouton(G1= V1 , rV1 , rE1 , G2= V2 , rV2 , rE2 )
retourne un appariement m ⊆ V1×V2
m←∅
bestm ← ∅
itérer
cand ← {(u1 , u2 ) ∈ V1×V2 − m | score(m ∪ {(u1 , u2 )}) est maximal}
cand ← {(u1 , u2 ) ∈ cand | f (look _ahead(u1 , u2 )) est maximal}
où look _ahead(u1 , u2 )={(u1 , v1 , l) ∈ rE1 | ∃v2 ∈ V2 , (u2 , v2 , l) ∈ rE2
∪ {(u2 , v2 , l) ∈ rE2 | ∃v1 ∈ V1 , (u1 , v1 , l) ∈ rE1
∪ {(v1 , u1 , l) ∈ rE1 | ∃v2 ∈ V2 , (v2 , u2 , l) ∈ rE2
∪ {(v2 , u2 , l) ∈ rE2 | ∃v1 ∈ V1 , (v1 , u1 , l) ∈ rE1
−descr(G1 ) m{(u1 ,u2 )} descr(G2 )
sortir si ∀(u1 , u2 ) ∈ cand , score(m ∪ {(u1 , u2 )}) ≤ score(m)
et look_ahead(u1 , u2 ) = ∅
choisir aléatoirement un couple (u1 , u2 ) dans cand
m ← m ∪ {(u1 , u2 )}
si score(m) > score(bestm ) alors bestm ← m finsi
fin itérer
retourner m

Voici la source :Champin, Solnon, Mesurer la similarité de graphes étiquetés, Actes JNPC’03
0

Discussions similaires

Héritage et constructeur de la classe fille
Cookiem -
aylaj -

4 réponses
Heritage et Constructeur
codefalse -
tinaprincesse -

12 réponses
Héritage et dialogue entre les classes
deterred -
LordBob -

5 réponses
heritage de uml vers mysql?
kyousra -
medhadjkacem20288877 -

2 réponses
Héritage et protected
krimog -
krimog -

6 réponses
Rejoignez-nous