Pointeurs de fonction dans des structures

Soyez le premier à donner votre avis sur cette source.

Snippet vu 13 612 fois - Téléchargée 30 fois

Contenu du snippet

Ce code montre comment stocker vos fonctions dans une structure et cmt les utiliser par la suite...

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

Ajouter un commentaire

Commentaires

Messages postés
402
Date d'inscription
mardi 1 mai 2001
Statut
Membre
Dernière intervention
15 août 2011

Cyrille2, non ce n'est pas inutile, tu pourrais, par exemple, avoir ce genre de chose:

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 ::.)~
Messages postés
113
Date d'inscription
vendredi 16 août 2002
Statut
Modérateur
Dernière intervention
15 mai 2005

Bjr!

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
Messages postés
7
Date d'inscription
jeudi 11 décembre 2003
Statut
Membre
Dernière intervention
19 avril 2006

Nitric, c'est dommage que tu ne fasses pas de commentaire...

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...
Messages postés
1329
Date d'inscription
vendredi 15 août 2003
Statut
Membre
Dernière intervention
16 juin 2010
2
Lol tu m'étonnes, ce code est bien pour savoir comment ca marche mais de la a se mettre en Initié ya un gouffre
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
Messages postés
402
Date d'inscription
mardi 1 mai 2001
Statut
Membre
Dernière intervention
15 août 2011

`réinventer la notion d'objet` ... et bien ... sans commentaire ...




~(.:: NitRic ::.)~
Afficher les 8 commentaires

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.