C++

Pointeurs sur fonction membre, héritage, toussa

Recherche :

Mot : Pseudo : Filtrer
Bas de page
Auteur	Sujet : Pointeurs sur fonction membre, héritage, toussa

Mackila

Note : le problème n'est pas un problème pour déclarer ou appeller une fonction membre à travers un pointeur.
Note² : j'ai lu la premiere page des sujets C++ donnés par la recherche : "pointeur fonction membre". J'ai lu aussi quelques truc sur codeproject (dans ce genre la).

Imaginons une classe de base (

class Base ;

) et une classe dérivée (

class Fille ;

).
Dans une des méthodes de la classe Base, on trouve un :

void (Base::* fonctionAAppeller)() f = kekchoseQuiMeDonneUneFonctionAAppeller() ;

La feinte, c'est que ce

kekchoseQuiMeDonneUneFonctionAAppeller()

est virtuel, et renvoie en réalité un

void (Fille::*)()

.

La question : Puis-je travailler en considérant des pointeurs sur fonction membre d'une classe dérivée comme pointeurs sur fonction membre de la classe parente ? (le but serait d'éviter d'avoir à écrire 500

virtual void Base::fonction_xxx() {}

, avec xxx de 000 à 499 !
Note : Base peut hériter multiplement de plein de trucs, mais Fille n'hérite que de Base.

J'ai bien une petite idée de la réponse, vu que pour que ca marche il a fallu que je caste mon pointeur comme un gros barbare, mais on sait jamais, quelqu'un a peut être déja fait ce genre de trucs...

Publicité

nargy

heu j ai pas tout pige, mais si tu as:

virtual Mere::fct();
virtual Fille1::fct();
virtual Fille2::fct();
virtual Fille3::fct();
...

alors les pointeurs vers toutes ces fonctions sont de aussi type virtual Mere::fct();

Mackila

Ouaip mais la ca serait plutot un truc du genre :

Code :

class Base {
public :
virtual void appellerFonctionX(int x)
{
void(Base::*fonction)() = 0 ;
fonction = table[x] ;
if ( fonction == 0 ) throw exception("pas content" ) ;
(*this.*fonction)() ;
}
private :
map<int, void(Base::*)()> table ;
protected :
void enregistrer(int i, void(Base::*f)())
{
table[i] = f ;
}
} ;
class Fille : public Base {
public :
void f1() ;
void f2() ;
void f3() ;
//......
Fille()
{
enregistrer(1, (void(Base::*)())f1 ) ;
enregistrer(2, (void(Base::*)())f2 ) ;
enregistrer(3, (void(Base::*)())f3 ) ;
//......
}
} ;

J'aurais plutot tendance à dire que je vais etre obligé de déclarer plein de virtual void fx() ; dans ma classe de base, mais bon...

edité : j'me rappellais plus comment c'était fait, j'ai remis la map à la place du switch...

Message édité par Mackila le 23-03-2006 à 19:24:11

nargy

> J'aurais plutot tendance à dire que je vais etre obligé de déclarer plein de virtual void fx() ; dans ma classe de base, mais bon...
- exact

Je ne pige pas ce que tu veut faire, ça me parait pas très organisé.

-? Est tu sûr d avoir besoin de N classes filles contenant M fonctions virtuelles?

Une autre organisation:
N classes filles, chacune mères de M classes petite-fille.

Encore une autre organisation:
N*M classes filles

Tu peut mixer ces solutions avec des templates...

Mackila

En gros je cherche à me faire un outil pour écrire facilement des séquences, pour gérer un processus industriel.
Je dois donc pouvoir lancer des traitements, attendre, vérifier des comptes-rendus, tout en vérifiant en permanence un ensemble de conditions de fonctionnement.

Ma classe Base s'appelle en fait BaseSequence, et Fille est en réalité SequenceTruc.

Mon moteur de séquence fait partie de BaseSequence, et ressemble à ca :

Code :

class BaseSequence {
//....
private :
map<int, void(BaseSequence::*)()> tableEtapes ;
public :
bool run() ;
protected :
virtual void PreSequence() ;
virtual void PostSequence() ;
//....
} ; // class BaseSequence
void PreEtape()
{
}
void PostEtape()
{
}
bool BaseSequence::run()
{
do
{
Sleep(10) ;
PreEtape() ;
void(Base::*traitementEtape)() = 0 ;
traitementEtape = tableEtapes[numeroEtape] ;
if ( traitementEtape == 0 ) throw exception("Etape inexistante" ) ;
(*this.*traitementEtape)() ;
PostEtape() ;
}
while ( ! estTerminee() ) ;
return true ; // Séquence terminée avec succès
}

Je peux ainsi mettre dans PreEtape() et PostEtape() mon code de vérification, qui peut lancer ce qu'il veut comme exception si une des conditions nécessaire au fonctionnement n'est pas bonne.

Dans ma classe SequenceTruc, je me déclare des fonctions d'étape, que j'associe à un numéro d'étape en les insérant dans ma map tableEtapes.

Mon problème étant : est ce que je peux raisonnablement stocker des void(SequenceTruc::*)() dans une map qui attend des void(BaseSequence::*)(), sachant que SequenceTruc hérite et n'hérite que de BaseSequence.

Sinon je vois pas comment faire à part me déclarer un nombre suffisant de fonctions "étapes" virtuelles dans ma classe BaseSequence, mais ca fait bourrin je trouve ...

edit : au passage, ca marche comme ca, mais vu que pour insérer mes pointeurs void(SequenceTruc::*)() dans ma map, j'ai casté comme un gros bourrin, j'me dis qu'il y a un truc foireux dans le bazar... Et j'ai pas envie de laisser un truc foireux dans ce code...

edit² : tiens, j'me demande si yaurait pas un holdup à faire à coup de templates... Faudra que je voie ca, demain...

Message édité par Mackila le 23-03-2006 à 22:17:52

nargy

> void(Base::*traitementEtape)();
- fait un typedef, sinon c est pas pratique.

> est ce que je peux raisonnablement stocker des void(SequenceTruc::*)() dans une map qui attend des void(BaseSequence::*)()
- oui à condition de spécifier que c est une fonction virtuelle, je peut pas te donner la syntaxe, mais tu doit avoir ``virtual`` quelque part.

> Sinon je vois pas comment faire à part me déclarer un nombre suffisant de fonctions "étapes" virtuelles dans ma classe BaseSequence, mais ca fait bourrin je trouve ...
- je n ai pas l impression que tu ait besoin d autre chose que:

Code :

// une étape générique
classe Etape
{
virtual void PreEtape() throw Error =0;
virtual void PostEtape() throw Error =0;
virtual void Etape() throw Error =0;
}
// un type d étape particulier
class EtapeCeci: public Etape
{
EtapeCeci(...) { ... }
void PreEtape() { ... }
void PostEtape() { ... }
void Etape() { ... }
}
// un autre type d étape particulier
class EtapeCela: public Etape
{
EtapeCela(...) { ... }
void PreEtape() { ... }
void PostEtape() { ... }
void Etape() { ... }
}
// une séquence composée d étapes
class Sequence
{
Etape* etapes[];
void ajouter(Etape*) { ... }
void supprimer(Etape*) { ... }
void go() throw Error
{
etapes[i]->preEtape();
etapes[i]->Etape();
etapes[i]->postEtape();
}
}

Cherche sur le web: functionoids
Une bonne doc:
http://snet.wit.ie/GreenSpirit/c++ [...] #faq-33.10

nargy

errata:

Code :

class Sequence
{
Etape* etapes[];
void ajouter(Etape*) { ... }
void supprimer(Etape*) { ... }
void go() throw Error
{
for(i=0;....i++)
{
etapes[i]->preEtape();
etapes[i]->Etape();
etapes[i]->postEtape();
}
}
}

Mackila

L'idée d'indiquer que mon pointeur de fonction pointe sur quelque chose de virtual me plait bien, ca me permettrait de valider le fonctionnement de mon bazar comme je l'ai testé aujourd'hui.

Merci pour le lien, j'ai parcouru, je lirai ca calmement demain.

Enfin au pire des cas, je peux écrire une méthode run() par séquence, ca me tuera pas (mais bon c'est domage, le but aurait été de n'avoir de défini dans la classe SequenceTruc que ce qui a rapport directement avec le process de la dite séquence. Histoire d'éviter d'oublier un truc le jour lointain ou je voudrai rajouter une séquence...)

nargy

Le coup du pointeur sur fonction viruelle, ça me parait louche.
A mon avis tu doit pouvoir faire autrement.

> Enfin au pire des cas, je peux écrire une méthode run() par séquence
- Alors ça je ne comprends pas... justement le but de faire des étapes virtuelles est d avoir qu un seul run().

Avoir des Etapes fonctionoides te permettraient d ajouter des conditions, et des sauts.

Par exemple une étape condition:

Code :

class EtapeVerifierPorte: public Etape
{
Etape* sioui;
Etape* sinon;
bool resultat;
EtapeVerifierPorte(Etape* e_sioui, Etape* e_sinon): sioui(e_sioui), sinon(e_sinon) {}
// vérifie la validité de l étape
void PreEtape()
{ if (!sioui) throw Error; if (!sinon) throw Error; }
// l étape
void Etape()
{
resultat=verifierFermeturePorte();
}
// retourne la prochaine étape
Etape* PostEtape()
{ return resultat?sioui:sinon; }
}

Ensuite tu peut écrire une séquence qui utilise cette etape:

Code :

Etape* e_fermer=new EtapeFermerPorte()
Etape* e_chauffer=new EtapeChauffer()
Etape* e_arret=new EtapeArretUrgence()
Etape* e_verifierporte=new EtapeVerifierPorte(e_chauffer, e_arret);
Sequence* s;
s.ajouterEnPremier(e_fermer);
s.ajouter(e_verifierporte);
s.ajouter(e_arret);
s.ajouter(e_chauffer);
s.run();

Mackila

En fait j'suis en train de lire ceci, et j'suis en train d'essayer de comprendre tout le bazar pour voir si ce que je fais ne serait pas autorisé, en fait :??:

Code :

struct A { };
struct B : A { virtual void f(); };
struct C : A { virtual void g(); };
void h() {
// base class pointer to derived object
A *objptr = new C;
// base class member pointer to derived member
void (A::*memptr)() = (void (A::*)()) &C::g;
// ... handled as a pair ...
// ... eventually dereferenced as a pair ...
(objptr->*memptr)();
}

edit : et ca. Ouaip enfin ce que j'ai tenté a l'air foireux. Tout le monde n'a pas l'air d'accord la dessus...

Message édité par Mackila le 24-03-2006 à 09:58:28

Publicité

nargy

ben, moi j ai rien contre les pointeurs sur fonctions virtuelles, mais franchement, c est vraiment bizarre que tu en arrive à ça: les fonctions virtuelle sont faites justement pour éviter d avoir des pointeurs sur fonctions pas pratiques à utiliser.

Tu devrai vraiment lire la doc que je t ai filé, elle explique bien. Je suis quasiment sûr que tu y trouvera ce que tu cherche.

Sinon, j ai pas très bien compris la structure de ton programme, mais est ce que avoir des étapes polymorphes ne suffirait pas?

nargy

struct A { virtual void etape(); };
struct B : A { void etape(); };
struct C : A { void etape(); };
A* b=new B();
A* c=new C();
b->etape(); // appelle B::etape();
c->etape(); // appelle C::etape();

Mackila

Parcequ'à chaque cycle, je veux pouvoir décider de l'étape qui sera executée au cycle d'après.
Et j'ai fait ca avec des pointeurs de fonction. Et pour pas me prendre la tête avec les pointeurs de fonction, bah je les ai planqués derrière une map<int, pointeurDeFonction> et je travaille avec l'int.

Effectivement, si mon downcast de pointeur de fonction s'avérait être véreux à mort, alors il me "suffirait" de définir dans ma classe BaseSequence une tripotées de fonctions virtuelles :

Code :

class BaseSequence {
// [...]
protected :
virtual void etape_initiale() ;
virtual void etape_1() ;
virtual void etape_2() ;
virtual void etape_3() ;
virtual void etape_4() ;
// [...]
virtual void etape_247() ;
virtual void etape_248() ;
// [...]
private :
void etapeInvalide() ;
// [...]
} ; // class BaseSequence
void BaseSequence::etapeInvalide()
{
cerr << "etapeInvalide #" << etapeCourante << endl ;
termineSequence() ;
}
void BaseSequence::etape_initiale() { etapeInvalide() ; }
void BaseSequence::etape_1() { etapeInvalide() ; }
void BaseSequence::etape_2() { etapeInvalide() ; }
void BaseSequence::etape_3() { etapeInvalide() ; }
// [...]
void BaseSequence::etape_247() { etapeInvalide() ; }
// [...]

C'est vrai qu'avec cette solution, j'évite d'avoir à remplir mon tableau de pointeurs dans l'initialisation des séquences.

Voila à quoi ressemble le code, et ce que j'ai trouvé jusqu'à maintenant :

SequenceInitialisation.cpp

Code :

// [...]
bool SequenceInitialisation::PreEtape()
{
verificationPressions() ;
if ( interfaceUtilisateur.ArretUrgence() ) throw exception("Arrêt d'urgence demandé !" ) ;
if ( interfaceUtilisateur.annuler() ) return false ;
return true ;
}
void SequenceInitialisation::InitEtapes()
{
cout << "SequenceInitialisation::InitEtapes()" << endl ;
AjouteEtape(DEBUT_SEQUENCE, static_cast<fonctionEtape>(etape_initiale) ) ;
AjouteEtape(1 , static_cast<fonctionEtape>(etape_1 ) ) ;
// [...]
}
void SequenceInitialisation::etape_initiale()
{
cout << "Demarrage de la séquence d'initialisation" << endl ;
etapeSuivante() ;
}
void SequenceInitialisation::etape_1()
{
// [...]
}
// [...]

SequenceInitialisation.h

Code :

// [...]
class SequenceInitialisation : public BaseSequence {
// [...]
} ; // class SequenceInitialisation
// [...]

BaseSequence.cpp

Code :

// [...]
void BaseSequence::etapeSuivante()
{
etapeCourante += 1 ;
// [...]
}
void BaseSequence::AjouteEtape(int numeroDEtape, void (BaseSequence::* fonctionDeLEtape)())
{
tableEtapes[numeroDEtape] = fonctionDeLEtape ;
}
bool BaseSequence::demarre()
{
// [...]
void (BaseSequence::* etape)() = 0 ;
etape = tableEtapes[etapeCourante] ;
if ( etape != 0 )
{
(*this.*etape)() ;
}
// [...]
}
// [...]

BaseSequence.h

Code :

// [...]
class BaseSequence : // [...]
{
// [...]
protected :
void etapeSuivante() ;
void AjouteEtape(int numeroDEtape, void (BaseSequence::* fonctionDeLEtape)()) ;
private :
int etapeCourante ;
map<int, void (BaseSequence::*)() > tableEtapes ;
public :
bool demarre() ;
// [...]
} ; // class BaseSequence
// [...]

Ceci compile sans problème (Visual C++ 7.0.9500), et fonctionne aussi. Pour tester cette histoire de cast de pointeur de fonction membre, je me suis déclaré une classe bidon (en lui mettant des méthodes virtuelles), et j'ai modifié l'héritage de SequenceInitialisation en :

Code :

class SequenceInitialisation : public bidon, public BaseSequence {
// [...]
} ; // class SequenceInitialisation

J'obtiens alors à la compilation un warning de niveau 1 (C4407) : Cast entre différentes représentations du pointeur membre, le compilateur peut générer du code incorrect.
L'aide pour ce warning me propose alors d'inverser l'ordre de l'héritage :

Code :

// cast entre différentes représentations du pointeur en membre, le compilateur peut générer du code incorrect
// Un cast de type incorrect a été détecté.
// L'exemple suivant génère l'avertissement C4407 :
// C4407.cpp
struct C1
{
};
struct C2
{
};
struct C3 : C1, C2
{
};
typedef void(C3::*PMF_C3)();
typedef void(C2::*PMF_C2)();
PMF_C2 f1(PMF_C3 pmf)
{
return (PMF_C2)pmf; // C4407, change type of cast,
// or reverse base class inheritance of C3 (i.e. : C2, C1)
}
int main()
{
}

Et effectivement, si j'écris ca ca fonctionne :

Code :

class SequenceInitialisation : public BaseSequence, public bidon {
// [...]
} ; // class SequenceInitialisation

Ce que j'en retire, c'est que le cas a été prévu dans le compilo de visual studio (si quelqu'un pouvait tester avec le 2005...), mais je ne sais toujours pas si c'est quelque chose d'autorisé par le standard.

Après on peut faire un sondage : vous préférez la version pointeurs de fonctions, ou la version masse fonctions virtuelles (si je finis par choisir cette dernière, va falloir que je me ponde une macro ou kekchose pour me générer les X fonctions de base [:petrus75] )

nargy

> Parcequ'à chaque cycle, je veux pouvoir décider de l'étape qui sera executée au cycle d'après.

- Dans ce cas tu peut faire retourner à Etape::postEtape() une pointeur vers l étape suivante.

> Et pour pas me prendre la tête avec les pointeurs de fonction, bah je les ai planqués derrière une map<int, pointeurDeFonction>

- Au lieu de stocker des pointeurs sur fonction, tu peut directement stocker des étapes.

Relis le code que j ai posté plus haut, il fait la même chose, mais il est plus simple à lire: ne necessite pas plein de fonctions virtuelles, ne necessite pas de pointeur sur fonction, permet une meilleure organisation de ton programme.

Il me semble que tu n a pas saisi comment fonctionnent les classes abstraites et les fonctions virtuelles. Je ne saurais que te consiller _vivement_ de lire une doc sur le sujet. Un petit coup de google et tu trouvera plein de tutoriaux.

Mackila

Si je décide de remplacer mes étapes "fonctions" par des étapes "class etape", ca va me donner un truc du genre :

Code :

//---------------------------------------------------------------------------
class BaseEtape {
// ...
protected :
Sequence* sequence ;
public :
void setSequence(Sequence*) ;
virtual void traite() = 0 ;
// ...
} ; // class BaseEtape
class Sequence {
// ...
public :
Sequence(BaseEtape* etapeInitiale) ;
protected :
BaseEtape* etapeCourante ;
// ...
} ; // class Sequence
bool Sequence::demarre()
{
do
{
if ( ! PreEtape() ) return false ;
if ( etapeCourante != 0 )
{
etapeCourante->traite() ;
}
else
{
throw exception("Etape invalide !" ) ;
}
if ( ! PostEtape() ) return false ;
}
while( ! estTerminee() ) ;
return true ;
}
//---------------------------------------------------------------------------
class Etape1_seqExemple : public BaseEtape {
// ....
public :
void traite() ;
} ; // class Etape1_seqExemple
class Etape2_seqExemple : public BaseEtape {
// ....
public :
void traite() ;
} ; // class Etape2_seqExemple
// ....
void Etape1_seqExemple::traite()
{
// Ecrire ici ce qu'il y a faire dans l'étape 1.
// Quand on veut passer à une autre étape, il faut modifier le pointeur dans
// la sequence...
sequence->etapeSuivante( ??????? ) ; // <= faut connaitre la séquence suivante,
//la :o, en plus de connaitre la sequence... Alors oui j'ai vu ton exemple dans lequel le
//constructeur de telle étape prend comme paramètre des pointeurs sur les étapes
//suivantes possibles, mais bon ca va devenir l'horreur ce truc, surtout si je
//commence à avoir des boucles dans mes séquences !
}
void Etape2_seqExemple::traite()
{
// ....
if ( /*....*/ )
{
sequence->etapeSuivante( ????? ) ;
}
}
// ....
//---------------------------------------------------------------------------

J'suis désolé mais la je voie pas ou c'est plus simple...
Ce qui serait cool c'est que les mecs qui passeront derrière moi n'aient pas besoin d'être experts en C++ pour modifier le comportement d'une séquence... (avec ton histoire, j'imagine même pas la tête du pavé que je vais trouver lors de l'instanciation de la séquence, pour laquelle va falloir instancier toutes les étapes et leur renseigner tous les pointeurs vers les étapes suivantes...)

Le "modèle" que j'ai en tête, c'est le truc con :

Code :

class BaseSequence {
// ....
private :
int etapeCourante ;
public :
virtual void traiteSequence() =0 ;
void demarre() ;
// ....
} ; // class BaseSequence
class SequenceSwitch : public BaseSequence {
public :
void traiteSequence() ;
} ; // class SequenceSwitch
void SequenceSwitch::traiteSequence()
{
switch( etapeCourante )
{
case 0 :
// traitement de démarrage de la séquence
break ;
case 1 :
// traitement étape 1
break ;
case 2 :
// traitement étape 2
break ;
// .....
}
}
void BaseSequence::demarre()
{
do
{
PreEtape() ;
traiteSequence() ;
PostEtape() ;
}
while( ! estTerminee() ) ;
}

.....

Boarf. En écrivant ca, j'suis en train de me demander si j'aurais pas mieux fait de faire directement mon switch comme un bourrin sans chercher compliqué. La avec mon idée de départ, j'ai remplacé un switch par une map avec des pointeurs de fonction [:pingouino] .

Merde je suis trop con des fois . J'ai du fumer un truc pas clair depuis hier...

Ca sert des fois, de tout écrire sur le forum, on se rend compte qu'en fait on cherche à faire un truc hyper tordu

Message édité par Mackila le 24-03-2006 à 17:44:11

Joel F

Real men use unique_ptr

Pour l'instanciation passe par une Factory .

LE couple factory+functor est LA maniere de régler ces problemes. Au pire tu generes un ficheir txt genre xml qui contient la luiste des instanciations, tu le lit et le passe à la factory qui te renvoie l'objet sequence tout pret.

le switch ... autant faire du C

++fab

victime du syndrome IH

Joelf> Un feed-back de Loki ?

Message cité 1 fois

nargy

> (avec ton histoire, j'imagine même pas la tête du pavé que je vais trouver lors de l'instanciation de la séquence, pour laquelle va falloir instancier toutes les étapes et leur renseigner tous les pointeurs vers les étapes suivantes...)

Bof, reprends l exemple que je t ai donné des la classe VerificationPorte: tu passe au constructeur de la classe Etape un pointeur vers l étape suivante. Tu peut même en avoir plusieurs:

Code :

new EtapeFermerPorte(
new EtapeVerifierPorte(
new EtapeChaufferFour(
new EtapeOuvrirPorte(0),
new EtapeArretUrgence(0)
)
)
)

Correspond à la séquence:
- FermerPorte
- VerifierPorte, si problème ArretUrgence
- sinon ChaufferFour
- puis OuvrirPorte

Tu peut changer les étapes suivantes au cours de la séquence, tu peut ajouter des conditions ou des variables globales dans les constructeurs...

Tu peut simuler des conditions, des boucles, des sauts...

Et en prime tu peut avoir une belle IHM sur tout ça pour gérer indépendamment les étapes et les séquences, faire des sous-séquences, définir des conditions ou variables globales, contrôler l execution de la séquence pas à pas, enregistrer/charger des séquences prédéfinies...

Sans IHM, à mon avis tu te prends la tête, autant coder directement en C ou même en BASIC. C est simple le BASIC.

Avec le switch, tu va beaucoup plus galérer, comme avec tes pointeurs de fonction. Enfin, je te laisse le découvrir.

Message cité 1 fois

Joel F

Real men use unique_ptr

++fab a écrit :

Joelf> Un feed-back de Loki ?

loki [:spyer] c'est gros, gras, enorme.
Depuis que j'utilise des factory, des typelistes ou des SmallObjects, mon poil est plus brillant et mon code
a les yeux qui pétillent :sol:

Blague à part : l'utiliser c'est l'adopter. En outre, c'est une vrai source d'inspiration. Grace aux typelist et multi-stratégies, pas mal de ems interfaces et de mes codes ont gagné en lisibilité//flexibilité

Message édité par Joel F le 24-03-2006 à 19:20:27

Mackila

nargy a écrit :

[...]

Et en prime tu peut avoir une belle IHM sur tout ça pour gérer indépendamment les étapes et les séquences, faire des sous-séquences, définir des conditions ou variables globales, contrôler l execution de la séquence pas à pas, enregistrer/charger des séquences prédéfinies...

[...]

Avec le switch, tu va beaucoup plus galérer, comme avec tes pointeurs de fonction. Enfin, je te laisse le découvrir.

Ouaip ca serait top, je me coderais bien un système complet d'écriture d'automatismes à la norme IEC 61131-3, avec l'IDE, les modules d'entrées sorties toussa.

Sauf que le projet est à terminer pour hier.

Je pense rester sur le switch (vais virer les pointeurs de fonction), avec une enum pour les numéros d'étape (histoire que l'IHM qui observe la séquence ne pete pas les plombs si j'insere une étape en plein milieu du bazar).

Avec le switch, je ne pense pas galérer, vu qu'il n'est pas prévu qu'il puisse y avoir deux étapes actives dans la même séquence. Au pire si ya besoin de ce genre de chose, alors j'utiliserai deux séquences.

Citation :

[...] Loki [...]

Ca m'a l'air sympa, ca. Je mets ca dans ma liste des trucs-à-regarder-quand-j'aurais-du-temps...

FORUM HardWare.fr

Programmation

C++

Pointeurs sur fonction membre, héritage, toussa

Sujets relatifs
[C] Problème de pointeurs et d'allocation	[JSP] : out.println dans une fonction
[PHP] Fonction mail() qui ne marche pas	fonction qui clear stdout
[PHP-MySQL] Fonction CONCAT_WS() dans une page	[VBS] Utiliser les fonction d'un autre script vbs
fonction mediane vba	fonction recursive
Appelle d'une fonction via XML dans une classe	[EXCEL] fonction comparaison entre cellule et tableau
Plus de sujets relatifs à : Pointeurs sur fonction membre, héritage, toussa

Page générée en 0.200 secondes