Discussion :

[Letthieum]

Bonjour

j'ai une classe Classe qui contient entre autre une structure nommée INSTRUCTION avec 2 pointeurs sur fonction + 1 tableau:

Classe.h:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
 
#ifndef _CLASSE
#define _CLASSE
 
#include <iostream>
#include <vector>
 
class Classe{
 
	public:
		struct INSTRUCTION{
			int longueur;
			void (Classe::*ptr_f_1)(void) = nullptr;
			void (Classe::*ptr_f_2)(void) = nullptr;
		};
 
		std::vector<INSTRUCTION> table;
 
	public:
		Classe();
		~Classe();
 
		void fonction_1();
		void fonction_2();
		void fonction_3();
		void fonction_4();
};
 
#endif

Classe.cpp:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
#include "Classe.h"
 
Classe::~Classe(){}
 
Classe::Classe(){
	table = {	{2,&Classe::fonction_1,&Classe::fonction_2},
				{3,&Classe::fonction_3,&Classe::fonction_4},
		 	};
}
 
 
 
void Classe::fonction_1(){ std::cout << "fonction_1." << std::endl; }
void Classe::fonction_2(){ std::cout << "fonction_2." << std::endl; }
void Classe::fonction_3(){ std::cout << "fonction_3." << std::endl; }
void Classe::fonction_4(){ std::cout << "fonction_4." << std::endl; }

voici mon main:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
 
#include "Classe.cpp"
 
int main(){
 
 
	Classe classe;
	std::cout << classe.table[1].longueur << std::endl;
 
	classe.table[0].ptr_f_1;
 
	return 0;
}

Voici mon problème: je n'arrive à lancer aucun fonction membre de ma classe dans mon main(). J'ai essayé plein de syntaxes différentes et la seule qui est compilée sans erreur est celle-ci:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
 
classe.table[0].ptr_f_1;

Cependant, même si G++ compile, il ne se passe rien à l'exécution...

Help! Quelle est la bonne syntaxe? Qu'est-ce qui cloche dans mon code?

Merci infiniment pour le temps que vous accorderez à m'aider !

A+

[dalfab]

Bonjour,

Tu as le nom du pointeur membre sur la fonction.
Maintenant, il faut
- l'appeler en ajoutant des parenthèses pour lui passer les paramètres (ici aucun).
- indiquer devant a quel objet elle s'applique en temps que pointeur membre d'où:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

 (classe .* classe.table[0].ptr_f_1)();

[Letthieum]

Merci beaucoup dalfab!

Donc si j'ai bien compris dans ton expression:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
(classe .* classe.table[0].ptr_f_1)();

- on met tout entre parenthèses -> c'est la fonction
- on passe les paramètres à la fin entre parenthèses, comme pour une fonction, du coup (ici aucun paramètre)
- le premier "classe" c'est l'objet que je viens d'instancier
- le ' * ' c'est l'opérateur de déréférencement du pointeur classe.table[0].ptr_f_1 pointant sur l'adresse de fonction_1(), donc la fonction membre fonction_1()

En tout cas ça fonctionne, alors merci encore

[Letthieum]

Bonjour à tous,

J'ai une classe Pointeur ayant comme attributs:
- une structure INSTRUCTION qui contient un entier et un pointeur sur fonction
- 1 tableau d'INSTRUCTIONs
- 2 fonctions membres:

Pointeur.h:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
#ifndef _POINTEUR
#define _POINTEUR
 
#include <vector>
#include <iostream>
 
class Pointeur{
	public:
		struct INSTRUCTION{
			int longueur;
			void (Pointeur::*ptr_fonction)(void) = nullptr;
		};
 
		std::vector<INSTRUCTION> table;
 
	public:
		Pointeur();
		~Pointeur();
 
		void fonction();
		void execute();
}; 
#endif

Pointeur.cpp:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
#include "Pointeur.h"
#include <iostream>
 
Pointeur::~Pointeur(){}
Pointeur::Pointeur(){
	table = {
		{2,&Pointeur::fonction}  
	};
}
 
void Pointeur::fonction(){
	std::cout << "Salut!" << std::endl;
}
 
void Pointeur::execute(){
	std::cout << Pointeur::table[0].longueur << std::endl;
	this -> Pointeur::table[0].ptr_fonction;                // PROBLEME
}

Voici mon main():

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
 
#include "Pointeur.cpp"
 
int main(){
 
	Pointeur pointeur;
	pointeur.execute(); // DEVRAIT AFFICHER "Salut!"
 
	return 0;
}

le programme compile correctement mais pointeur.execute() n'appelle pas la fonction membre fonction()...
le problème vient de la syntaxe de cette expression:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
	this -> Pointeur::table[0].ptr_fonction;

Si une bonne âme passant par là par hasard pouvait m'aider je lui en serait fort reconnaissant

A+

[dalfab]

Tu reposes la même question.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

 (this ->* this->table[0].ptr_fonction) ();

Qui peut se simplifier en:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

 (table[0].ptr_fonction) ();

[Letthieum]

[koala01]

Salut,

Il y a cependant quelques remarques à faire concernant ton code :

j'ai bien conscience du fait que c'est un code d'exemple qui cherchait juste à "donner une idée du problème", mais il faut toujours garder en tête que la toute première qualité d'un code, c'est d'être facilement lu et compris (par toi, mais aussi par les autres, surtout quand il est donné sur un forum).

L'idéal, est donc de toujours essayer

1. de donner des noms à tes types, tes données et à tes fonctions qui permettront à "celui qui lira ton code" de savoir ce que tu veux exactement faire.
2. de respecter les même conventions de codage tout au long du projet. C'est bien sur vrai sur l'ensemble d'un fichier, dans lequel tous les noms types, de variables et de fonctions devraient "prendre la même forme" (mais tu peux avoir une forme pour les types, une autre forme pour les données et, pourquoi pas, une troisième pour les fonction ), mais aussi tout au long du projet, même (et surtout) si ce projet est composé de plusieurs (centaines de) milliers de fichiers.

Le premier point permettra au lecteur de ne pas "se casser la tête" à essayer de comprendre ce que tu veux faire:

• si un type de donnée s'appelle Point, peu importe ce dont il est composé (ou la convention d'écriture que tu auras choisi), on a une idée précise de l'utilisation qui en sera fait.
• si une donnée (que ce soit une constante ou une variable) s'appelle liste_d_instructions, le lecteur saura qu'elle servira à fournir ... une liste des instructions qui devront être exécutées
• si une fonction porte le doux nom de translate, tourner ou appliquer_echelle, le lecteur saura précisément quel est l'objectif de celle-ci

Le deuxième point permettra au lecteur de ne "pas trop se poser de questions" sur le "sens global" du code, sur "quel mot correspond à quoi".

Par exemple, il n'y a pas vraiment de différence entre une classe et une structure en C++: ce sont tous les deux des éléments qui permettent de regrouper des données et des fonctions, de représenter des types de données.

En allant même plus loin, il n'y a pas non plus de différence entre une classe, une structure une énumération ou un alias de type : cela permet de définir ... un type de donnée.

Il n'y a donc aucune différence pour le nom de ces éléments (qui sont tous des types de donnée, de base) d'une manière différente, car cela augmente la "difficulté cognitive" (la difficulté avec laquelle le lecteur fera le lien entre ton code et ce qu'il est sensé faire) pour le lecteur.

C'est vrai, bien sur, au niveau d'un fichier, mais aussi au niveau de l'ensemble du projet, même (et surtout) si ce projet est composé de milliers, voir de centaines de milliers de fichiers différents, car, autrement, le lecteur va perdre énormément de temps à comprendre ce que signifie un nom commencant par une majucule, ou un nom écrit entierement en majuscules.

Ainsi, ta classe Classe aurait sans doute intérêt à s'appeler Script-- d'après ce que j'ai fini par comprendre de ton code (parce que j'ai "un peu de bouteile") -- la structure INSTRUCTION devrait, à tout le moins, respecter la même convention de codage que la classe Action.

De la même manière, ptr_f1 et ptr_f2 auraient sans doute intérêt à s'appeler exécuter_avant et executer_apres (voir, n'importe quel nom rendant encore plus clair l'objectif de chacune de ces fonctions) de manière à indiquer au lecteur l'objectif poursuivi par l'appel de ces fonctions particuilères dans le cadre précis de l'instance de la structure à partir desquelles on y fait appel.

Enfin, il faut te dire que le temps où chaque caractère du code "coutait un bras" en terme de ressources utilisées est révollu depuis bien longtemps et que, s'il n'y a rien de faux dans le code d'une fonction "simple" comme

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

void Classe::fonction_1(){ std::cout << "fonction_1." << std::endl; }

la facilité avec laquelle un tel code sera relu peut être encore fortement améliorée en séparant clairement le nom de la fonction que l'on définit (void Classe::fonction_1()) de la logique qu'elle doit appliquer, idéalement en "indentant" le code de manière à séparer clairement les différents blocs de code.

Encore une fois, peu importe la convention de codage qui sera utilisée, du moment que les différents éléments soient tous "facilement identifiables". Peu m'importe que tu écrive ce code sous la forme de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
void Classe::fonction_1(){ 
    std::cout << "fonction_1." << std::endl; 
}

de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
    void Classe::fonction_1(){ 
std::cout << "fonction_1." << std::endl; 
    }

ou de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
void Classe::fonction_1()
{ 
    std::cout << "fonction_1." << std::endl; 
}

pour autant, bien sur, que la même convention soit utilisée tout au long du fichier et du projet.

Ce qui importe surtout, c'est que le lecteur du code n'aie pas à se "casser la tête" pour retrouver les différentes parties du code : il aura déjà assez de raisons de se casser la tête pour arriver à comprendre ton objectif sans en rajouter

Après, il y a tout plein d'autres remarque beaucoup plus techniques qui pourraient être faites sur ton code. Je vais donc m'arrêter là pour aujourd'hui, histoire de te laisser assimiler tout cela. Et si tu en fais la demande, on passera sur l'aspect purement technique de ton problème

[Letthieum]

Salut Koala01,

je te remercie vivement pour tous ces conseils ainsi que pour leur pertinence, en tant que noob passionné autodidacte (dans l'ordre que tu veux ), c'est absolument ce dont j'ai besoin pour progresser !
Je tâcherai donc de les appliquer dans mes futurs projets

Je profite également de ta proposition de me faire part de tes remarques sur les volets techniques de mon code: surtout n'hésite pas, je suis preneur de tout ce qui pourrait me faire progresser.

En te remerciant encore une fois, bonne journée!

A+