Discussion :

[loicounet]

bonjour,

j'aimerais faire une sorte de fonctionnalité permettant le comptage d'appel de fonctions membres d'un objet
par ex: le comptage du nombre d'additions d'objet_type.(operator+ redéfini pour les additionner)
Cet objet_type est utilisé dans d'autres fonctions.

exemple de chose que je voudrais faire(mais qui ne marche pas^^)

Code :

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

1
2
3
4
5
6
7
8
9
10
11
main()
{
blablaba...
bool ret= false;
 
#define FLAG_COMPTAGE_ADDITIONS		//start! ^^
ret = mon_traitement(arguments...)		//en gros je veux compter le nombre d'additions effectuee sur objet_type uniquement dans cette fonction
#undef FLAG_COMPTAGE_ADDITIONS		//hold! ^^
 
cout<<"nombre d'additions effectuée"<<objet_type.nb_additions<<endl;
}

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
class objet_type{
    public:
	static int nb_additions;
 
	objet_type operator+=(objet_type const &op)
	{
 	  #ifdef FLAG_COMPTAGE_ADDITIONS
	     nb_additions++;
	 #endif
             blablabla
	}
};
int objet_type::nb_additions = 0;

Voila, j'espère que vous voyez a peu près ce que je voudrais faire? une sorte de chronomètre!cela me permettrait d'évaluer le coût en opération de diverses fonctions.
la fonction n'est pas nécessairement contenue dans le main, ça peut être une fonction contenue dans une autre classe...

Je cherche donc des idées pour concevoir quelque chose de ce style!

merci de vos suggestions

[koala01]

Salut,

Le flag en question est il à décider au moment de la compilation, ou carrément en "runtime"

sinon, cela devrait fonctionner sans problème, sous réserve d'initialiser correctement les variables statiques, et sous réserve que les différentes valeurs soient entourées des bonnes instructions préprocesseurs:

Ainsi, j'ai décidé ici qu'il faudrait compiler le projet en fournissant un argument de compilation définisstant COUNTENABLED, et j'ai créé la classe (basique, je l'accorde) suivante:

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
class myInt
{
    public:
        myInt(){}
        myInt(int i): i(i){}
        ~myInt(){}
        myInt& operator+=(myInt i2)
        {
#ifdef COUNTENABLED
            ++cpt;
#endif
            i+=i2.i;
            return *this;
        }
 
#ifdef COUNTENABLED
        static int cpt;
#endif
        int i;
    private:
};

(j'ai tout mis en public parce que l'encapsulation n'est pas indispensable pour comprendre le principe)

J'ai bien sur, respecté les obligations qui nous reviennent dans le cadre de la gestion de données statiques (cf la page de la FAQ qui y a trait) en initialisant le membre cpt dans un seul fichier d'implémentation sous la forme de

Code :

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

1
2
3
#ifdef COUNTENABLED
int myInt::cpt=0;
#endif

J'ai enfin créé une fonction main (tout aussi basique que la classe) sous la forme de

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
int main()
{
    myInt i(2);
    myInt i2(3);
    myInt i3(5);
    i+=i2;
    i+=i3;
    #ifdef COUNTENABLED
        std::cout<<"nombre d'operations :"<<myInt::cpt<<std::endl;
    #endif
    std::cout<<"valeur de l'objet finale :"<<i.i;
    return 0;
}

En compilant (sous gcc) avec une option -DCOUNTENABLED, j'obtiens la sortie console

nombre d'operations :2
valeur de l'objet finale :10

si je supprime cette option, j'obtiens la sortie

valeur de l'objet finale :10

Evidemment, il est toujours possible de travailler en "runtime" sous une forme proche de

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
30
31
32
33
34
 
class myInt
{
    public:
        myInt(){}
        myInt(int i): i(i){}
        ~myInt(){}
        myInt& operator+=(myInt i2)
        {
            if(flag)
                ++cpt;
            i+=i2.i;
            return *this;
        }
        static void setFlag(bool on=true, bool reset=true)
        {
            if(reset)
                cpt=0;
            flag=on;
        }
        static void resetCounter()
        {
            cpt=0;
        };
        int i;
        static int counter()
        {
            return cpt;
        }
    private:
        static int cpt;
        static bool flag;
 
};

sans oublier les initialisations des membres statiques

Code :

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

1
2
int myInt::cpt=0;
bool myInt::flag=false;

et, enfin, le code qui démontre le fonctionnement

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
int main()
{
    myInt i(2);
    myInt i2(3);
    myInt i3(5);
    //on veut le compte
    myInt::setFlag();//par défaut, cela remet le compteur à zero
    i+=i2;
    i+=i3;
    std::cout<<myInt::counter()<<std::endl;
    //on peut à tout moment "zeroter" le compteur... en cas de besoin ;)
    //on désactive le flag
    myInt::setFlag(false);
    i+=i2;
    i+=i3;
    std::cout<<myInt::counter()<<std::endl;
 
    return 0;
}

[loicounet]

Je viens de penser à une solution mais qui me dérange...
Une grosse variable globale

Mais bon j'aime autant éviter, c'est crado ca!


une question subsidiaire:
Si dans un fichier A je fais un

Code :

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

#define FLAG_BLA

Est ce que ce sera vu dans un autre fichier B?
(la question sous jacente est plutot est ce que l'ordre de précompilation/compilation est importante==> si le fichier A est traité aprés le fichier B...hum!)

[koala01]

Il faut savoir que tous les fichiers sont compilés séparément... et que tout ce qui a été fait lors de la compilation de l'un est oublié lors de la compilation de l'autre.

Ainsi, si tu place le #define dans un fichier d'en-tête (mettons define.h), seuls les fichiers qui incluent - éventuellement de manière indirecte - le fichier profiteront de ta directive define.

Cependant, il est aussi possible (et la méthode est fortement préférable dans le cadre de ce genre de définition) d'indiquer directement au compilateur que, lorsqu'il travaille, il doit considérer disposer d'une définition pour un (ou des) symboles "qui vont bien".

Sous gcc, cela se fait avec l'option -D suivie (sans espace) du symbole que tu veux définir.

La plupart des EDI que l'on trouve offrent d'ailleurs la possibilités (voir dans les options de compilation, selon l'EDI que tu utilise) de fournir ces directive "externes" (sous code::blocks, rajouter juste le symbole à définir dans menu Project->Build options ->onglet Compiler settings->sous onglet "#defines")

[loicounet]

merci de la réponse,

je vais y réfléchir afin de voir qu'est ce qui est le plus approprié!
à première vue, je dirais que la seconde solution marchera chez moi, mais c'est vrai que je préfère la première philosophie:
avec un

Code :

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

#define LE_FLAG_EN_MAJUSCULE_BIEN_VISIBLE

cependant mon souci revient, une fois que le #define est défini, est il possible de l' "enlever"?
le #undef ne convient pas, je crois qu'il empêche justement que la macro soit définie...

concrètement:

Code :

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

1
2
3
4
 
fonctionA();
fonctionB();
fonctionC();

si le flag est défini, on va compter toutes les opération += effectuée dans les fonction A,B et C ==>y a t il un moyen de compter seulement pour la fonctionA?

Apparemment je vois pas de solution évidente, le mieux est donc d'utiliser ta seconde solution!

[koala01]

Rien ne t'empêche de faire un mix des deux...

Et rien en t'empêche de disposer de plusieurs compteurs un qui s'applique sur fonctionA, l'autre sur fonctionB et le troisième sur fonctionC)...

Il t'appartient bien évidemment de choisir les opérations qui doivent être comptées "en commun", celle qui doivent être comptées "séparément", voir, d'envisager une fonction qui fait la somme de tous les compteurs séparés, et qui en profite pour calculer la moyenne et l'écart type

Disons les choses ainsi: je t'ai donné normalement tous les outils qui devraient te permettre de t'en sortir, maintenant, c'est à toi de "mouiller un peu ta chemise" en fonction de tes besoins finaux

[loicounet]

oui c'est sur, faut se lancer un moment ou un autre!
je tente de réfléchir au max à la meilleure solution avant de coder comme un cochon