Pointeurs de fonction dans des structures
3/5 (8 avis)
Snippet vu 16 263 fois - Téléchargée 32 fois
Contenu du snippet
Ce code montre comment stocker vos fonctions dans une structure et cmt les utiliser par la suite...
Voila, ce code doit donner 22 (20+1+1).
Réalisé pour Jingle
Source / Exemple :
#include <stdlib.h>
#include <unistd.h>
typedef struct compteur {
int nb;
void (*increment)(struct compteur *this);
void (*decrement)(struct compteur *this);
int (*getValue)(struct compteur *this);
void (*setValue)(struct compteur *this, int n);
void (*free)(struct compteur *this);
} compteur;
/* définition des différentes méthodes */
void __compteur__increment(compteur *this){
this->nb++;
}
void __compteur__decrement(compteur *this){
this->nb--;
}
int __compteur__getValue(compteur *this){
return this->nb;
}
void __compteur__setValue(compteur *this, int n){
this->nb = n;
}
/* fin des méthodes générales */
/* méthodes particulières */
// destructeur
void __compteur__free(compteur *this){
free(this); // libération
}
// constructeur
compteur *Compteur() {
compteur *n = malloc(sizeof(compteur)); // allocation
n->nb = 0;
// set des fonctions
n->increment = __compteur__increment;
n->decrement = __compteur__decrement;
n->getValue = __compteur__getValue;
n->setValue = __compteur__setValue;
n->free = __compteur__free;
return n;
}
/* fin méthodes particulières */
int main(void){
// création
compteur *c = Compteur();
// traitement
c->setValue(c,20);
c->increment(c);
c->increment(c);
// affichage
printf("%d\n",c->getValue(c));
// libération
c->free(c);
}
Conclusion :
Voila, ce code doit donner 22 (20+1+1).
Réalisé pour Jingle
A voir également
- Pointeurs de fonction dans des structures
- Sub ou fonction non définie - Forum VB.NET
- Fonction pow en c ✓ - Forum C
- Remise en fonction - Forum C / C++ / C++.NET
- Fonction calcul somme javascript - Forum Javascript / DHTML
- Fonction set vba - Forum Visual Basic
6 avril 2005 à 02:37
typedef struct _Module
{
type (*open)( ... );
type (*read)( ... );
type (*write)( ... );
type (*close)( ... );
}Module;
et ensuite, pouvoir charger différents modules sans code/fichiers/... supplémentaires:
Module mod;
modlog_01_load( &mod );
mod.open( ... );
mod.close( ... );
...
modlog_01_unload( &mod );
modlog_02_load( &mod );
mod.open( ... );
...
tu pourrais avoir plusieurs modules pour gérer des fichiers jounaux par exemple et pouvoir utiliser celui que tu veux sans code supplémentaire ... ce n'est qu'un exemple ...
Mais bref, ce n'est _pas_ inutile ...
gilids, c'était surtout le mot `réinventer`, c'était un peu trop non? Il n'a rien `réinventé` ici et ce n'est pas du OO, ca lui ressemble d'une certaine facon oui mais sans plus ...
Arnaud16022, depuis le `C99 je crois`, le (*...) est devenu optionnel en C aussi, `optionnel` car on peu encore utiliser cette `notation` ...
Au fait Cyrille2, faire de la `pseudo-OO` en C c'est vraiment `le bordel` et très laid alors continue dans cette voie, c'est beaucoup mieux ainsi :}
~(.:: NitRic ::.)~
5 avril 2005 à 23:32
tout d'abord, merci pour vos commentaires.
Je viens de rectifier le niveau de ce code, j'y suis peut-etre allé un peu vite... le voici donc débutant !
Pour ce qui est de la '->', il est imposible ici de l'utiliser, cette notation étant réservé aux pointeurs sur structures et non aux pointeurs dans les structures.
Enfin, suite à vos remarques sur la POO ... j'ai décidé de m'amuser un peu alors voici le résultat ...
en revanche ... je n'ai pas trouvé de solution pour le this ... car il est vrai que la cela peut paraitre étrange de faire c->methode(c); ... c vrai que c un peu inutile mais, c t juste pour me rapprocher de la POO!
voili
5 avril 2005 à 14:50
Je le précise au cas où, il ne s'agissait pas d'une critique.
Je trouve qu'il s'agit d'une sorte de pas intermédiaire entre le C et le C++. Mettre en commun des variables et les fonctions qui les manipulent constitue bien un des premiers objectifs de la POO.
Exemple :
typedef struct Nombre
{
int nb;
void (*Incrementer)(Nombre *this);
}
void IncrementerNombre(Nombre *this)
{
this->nb++;
}
void IncrementerNombrePair(Nombre *this)
{
this->nb += 2;
}
Ca ressemble beaucoup à :
class Nombre
{
int nb;
void Incrementer () virtual { this->nb++; }
}
class NombrePair : public Nombre
{
void Incrementer() virtual { this->nb += 2; }
}
D'ailleurs, le mécanisme utilisé pour les fonctions virtuelles en C++ est le même : une table de pointeurs appartenant à la zone mémoire contenant les données membres...
5 avril 2005 à 14:25
autre chose:
(*tab[i].test)(tab[i].nb)
heu...
c'est correct mais chiant, le C++ a crée une nouvelle notation (heu nouvelle, elle a bien 15 ans hein)
tab[i]->test(tab[i].nb)
c'est plus compréhensible comme ca non?
++
ad
5 avril 2005 à 13:07
~(.:: NitRic ::.)~
Vous n'êtes pas encore membre ?
inscrivez-vous, c'est gratuit et ça prend moins d'une minute !
Les membres obtiennent plus de réponses que les utilisateurs anonymes.
Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.
Le fait d'être membre vous permet d'avoir des options supplémentaires.