Discussion :

[SmallFitz]

Bonjour,

J'aimerais utiliser dans une méthode une variable, de type booléen par exemple, qui :
- ne soit pas détruite à la fin de cette méthode (pas d'instanciation statique)
- ne soit pas accessible depuis l'extérieur de cette méthode (ni une variable globale, ni une donnée membre)
- ne soit pas partagée entre plusieurs instances de la classe (donc non static).

Edit :
J'ai pensé à l'instanciation dynamique mais je ne sais pas comment je pourrai libérer la mémoire puisque cette variable n'est pas censée être accessible dans le destructeur.
N'importe quoi, je perdrai le pointeur dès la sortie de la méthode.

Avez vous des conseils ?

Merci d'avance !

Edit :
Résolu : C'est impossible.
Le mieux est de se servir des données membres.
Le seul "inconvénient" est que la variable est accessible depuis l'instance, et non pas uniquement à la méthode.
Ce qui donne :

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
35
36
#include <iostream>
 
using namespace std;
 
class A
{
        bool aFaire;
 
public:
        A() : aFaire(true)
        {}
 
        void m()
        {
                if(aFaire)
                {
                        aFaire = false;
                        cout << "\tTache 1." << endl;
                }
 
                cout << "\tTache 2." << endl;
        }
};
 
int main()
{
        A a1, a2;
 
        cout << "a1.m() (x1):" << endl; a1.m();
        cout << "a1.m() (x2):" << endl; a1.m();
        cout << endl;
        cout << "a2.m() (x1):" << endl; a2.m();
        cout << "a2.m() (x2):" << endl; a2.m();
 
        return 0;
}

Code :

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

1
2
3
4
5
6
7
8
9
10
11
a1.m() (x1):
        Tache 1.
        Tache 2.
a1.m() (x2):
        Tache 2.
 
a2.m() (x1):
        Tache 1.
        Tache 2.
a2.m() (x2):
        Tache 2.

[Bousk]

Bonjour,

avant de donner une quelconque solution possible, mon conseil serait que tu nous exposes le pourquoi du comment tu crois avoir ce besoin farfelu pour que l'on te redirige vers une vraie solution.

[SmallFitz]

Une méthode doit exécuter une seule fois, lors du premier appel, un bloc de code.
Aux appels suivants ce bloc sera ignoré, mais pas les autres.
Si cela avait été une fonction j'aurai codé ceci :

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
#include <iostream>
 
using namespace std;
 
void f()
{
        static bool aFaire = true;
 
        if(aFaire)
        {
                aFaire = false;
                cout << "Tache 1." << endl;
        }
 
        cout << "Tache 2." << endl;
}
 
int main()
{
        cout << "f() (x1):" << endl; f();
        cout << "f() (x2):" << endl; f();
 
        return 0;
}

Code :

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

1
2
3
4
5
f() (x1):
        Tache 1.
        Tache 2.
f() (x2):
        Tache 2.

Mais c'est une classe, et avec static la variable est partagée entre toutes les instances :

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
#include <iostream>
 
using namespace std;
 
class A
{
public:
        void m()
        {
                static bool aFaire = true;
 
                if(aFaire)
                {
                        aFaire = false;
                        cout << "\tTache 1." << endl;
                }
 
                cout << "\tTache 2." << endl;
        }
};
 
int main()
{
        A a1, a2;
 
        cout << "a1.m() (x1):" << endl; a1.m();
        cout << "a1.m() (x2):" << endl; a1.m();
 
        cout << endl << "a2.m() (x1):" << endl; a2.m();
 
        return 0;
}

Code :

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

1
2
3
4
5
6
7
8
a1.m() (x1):
        Tache 1.
        Tache 2.
a1.m() (x2):
        Tache 2.
 
a2.m() (x1):
        Tache 2.

Moi j'aimerais reproduire le même comportement qu'avec static sur une fonction, mais sur une méthode.
Le comportement de static n'étant plus le même, quoi utiliser ?

[Ehonn]

Une méthode doit exécuter une seule fois, lors du premier appel, un bloc de code.
[...]
Mais c'est une classe

Utilise le constructeur (?) ou un attribut initialisé à true par le constructeur et ta fonction le mets à false une fois le calcul effectué.

[SmallFitz]

Merci !

Utilise le constructeur (?)

Je ne souhaite pas exécuter la Tache 1 dès l'instanciation.

un attribut initialisé à true par le constructeur et ta fonction le mets à false une fois le calcul effectué.

Avec static dans une fonction ce qui est bien c'est que la static n'est accessible que depuis cette fonction.
L'utilisation d'une donnée membre augmente la portée de la variable à toute l'instance, or j'aimerais la garder cloisonnée à la méthode, c'est pourquoi je disais dans le premier post que je ne désirais pas utiliser de données membre.

Si le C++ le permet quoi, ce dont je commence à douter.

[Ehonn]

Si static ne fait pas ce que tu veux dans une fonction membre et que tu veux pas un attribut (private) en plus pour la gestion de cette fonction. Tu n'as qu'à appeler ta fonction libre dans ta fonction membre.

[SmallFitz]

Tu n'as qu'à appeler ta fonction libre dans ta fonction membre.

Mais appeler la fonction dans une méthode revient à utiliser static dans une méthode :

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
35
36
37
#include <iostream>
 
using namespace std;
 
void f()
{
        static bool aFaire = true;
 
        if(aFaire)
        {
                aFaire = false;
                cout << "\tTache 1." << endl;
        }
 
        cout << "\tTache 2." << endl;
}
 
class A
{
public:
        void m()
        {
                ::f();
        }
};
 
int main()
{
        A a1, a2;
 
        cout << "a1.m() (x1):" << endl; a1.m();
        cout << "a1.m() (x2):" << endl; a1.m();
 
        cout << endl << "a2.m() (x1):" << endl; a2.m();
 
        return 0;
}

Code :

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

1
2
3
4
5
6
7
8
a1.m() (x1):
        Tache 1.
        Tache 2.
a1.m() (x2):
        Tache 2.
 
a2.m() (x1):
        Tache 2. <= N'effectue pas la Tache 1.

Ce que je demande est ainsi impossible, dommage.
Ce qui s'en rapproche le plus étant l'utilisation des données membres, c'est ce que je vais utiliser (voir edit du premier post).

Merci encore pour l'aide apportée.

[koala01]

Salut,

Je suis peut être fatigué, mais je suis pris d'un doute...

La partie à exécuter conditionnellement doit elle être exécutée:

1. une et une seule fois, quel que soit le nombre d'instances de ta classe qui sera créé ou
2. une et une seule fois pour chaque instance créée de ta classe

Dans le premier cas, une variable statique dans le corps de la fonction est parfaitement justifiée: tu lui donne une valeur par défaut telle que tu passes dans la partie conditionnelle, et tu n'oublies pas (c'est quand même préférable ) de modifier cette valeur une fois que ce qui ne doit être fait qu'une seule fois a été effectué.

Dans le deuxième cas, tu n'as qu'à créer un membre correspondant dans ta classe, de préférence dans l'accessibilité privée.

Bien sur, cette valeur sera alors accessible depuis n'importe quelle fonction membre, mais peu te chaut: les fonctions membres qui n'ont aucun besoin de cette variable n'auront, purement et simplement, pas à s'en inquiéter

Où pourrait être le problème à travailler de la sorte

Finalement, la seule chose à laquelle tu devra être attentif, c'est au fait de donner un nom explicite à cette variable, de manière à ce qu'il exprime clairement le fait qu'elle ne doit être utilisée que dans un contexte particulier

[Bousk]

Je dirais même que c'est complètement ce à quoi sert l'accéssibilité privée.
Cacher l'implémentation réelle.

[SmallFitz]

Salut,

Je suis peut être fatigué, mais je suis pris d'un doute...

La partie à exécuter conditionnellement doit elle être exécutée:

1. une et une seule fois, quel que soit le nombre d'instances de ta classe qui sera créé ou
2. une et une seule fois pour chaque instance créée de ta classe

Je comprends ce doute, j'ai du inventer de toute pièce une situation concrète adaptée à mon besoin jugé farfelu, ce qui a dévié le fil de conversation du sujet initial : utiliser une Variable propre à une méthode d'une seule instance.
La modification de la variable depuis a1.m() ne doit donc pas affecter celle de a2.m().
Pour reprendre le cas concret, si a1.m()a exécuté la Tache 1, a2.m() doit pouvoir l'exécuté aussi :
Comportement indésirable :

Code :

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

1
2
3
4
5
6
7
8
a1.m() (x1):
        Tache 1.
        Tache 2.
a1.m() (x2):
        Tache 2.
 
a2.m() (x1):
        Tache 2. <= La Tache 1 n'est pas effectuée alors qu'elle devrait l'être.

Comportement désiré :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
a1.m() (x1):
        Tache 1.
        Tache 2.
a1.m() (x2):
        Tache 2.
 
a2.m() (x1):
        Tache 1. <= La Tache 1 est effectuée alors que a1 l'a déjà effectué, c'est ce qui est voulu.
        Tache 2.
a2.m() (x2):
        Tache 2.

Dans le deuxième cas, tu n'as qu'à créer un membre correspondant dans ta classe, de préférence dans l'accessibilité privée.

Contraint et forcé, c'est effectivement ce pour quoi j'ai opté (voir edit du premier post).

Bien sur, cette valeur sera alors accessible depuis n'importe quelle fonction membre, mais peu te chaut: les fonctions membres qui n'ont aucun besoin de cette variable n'auront, purement et simplement, pas à s'en inquiéter

Où pourrait être le problème à travailler de la sorte

Tu décris très bien le problème à travailler de la sorte :

Finalement, la seule chose à laquelle tu devra être attentif, c'est au fait de donner un nom explicite à cette variable, de manière à ce qu'il exprime clairement le fait qu'elle ne doit être utilisée que dans un contexte particulier

On est obligé de faire ça, ok, alors je le fais.
Mais je considère qu'être obligé de devoir faire confiance aux autre méthodes est dangereux et est une lacune du C++.

[koala01]

On est obligé de faire ça, ok, alors je le fais.
Mais je considère qu'être obligé de devoir faire confiance aux autre méthodes est dangereux et est une lacune du C++.

Je ne vois pas pourquoi...

Ce que font les différentes fonction dépend exclusivement de celui qui les code ou qui les modifie!

Ceux qui les utilisent ne font que les appeler, en espérant que celui qui les code aura fait correctement son boulot et que les fonctions font effectivement ce qu'on attend d'elle!

A priori, celui qui code la fonction, c'est toi ou un membre de ton équipe, vis à vis de qui tu es sensé faire un minimum confiance au niveau du code qu'il écrira.

C'est là qu'un nom judicieux du nom de ta variable interviendra car, si ton équipier (ou toi, dans trois mois) rencontre une variable nommée needFunctionFirstStep, il saura que cette variable est utilisée dans un but bien particulier.

Bien sur, rien ne l'empêche d'utiliser cette variable dans son propre code, peut etre parce qu'il se trouve justement dans une situation dans laquelle les conditions d'exécutions sont identiques, mais on s'attend alors à ce qu'il soit "suffisamment prudent" pour ne pas faire en sorte de modifier le comportement déjà établi de manière indue

Et, dans le pire des cas, un système de contrôle de version (SVN ou Git, par exemple) et une suite de tests clairement établis faciliteront le "retour en arrière" en cas d'erreur de cette sorte d'une part et le fait de se rendre compte que l'erreur a été commise de l'autre

[SmallFitz]

Le fossé en terme d'expérience qui nous sépare doit être à l'origine de ce désaccord.

Tu as mis en place des bonnes habitudes de codage pour éviter de provoquer ces bugs (que je vais tenter d'imiter), et tu utilises des outils pour les détecter. Tu en as l'habitude, cela t'est naturel.

En débutant je me dis : si C++ avait un petit mot clef de plus pour obtenir la bonne portée désirée, alors il n'y aurait même pas à y penser : cela provoquerait une erreur à la compilation.

Je serais curieux de savoir si ce comportement désiré est implémenté dans d'autres langages.

J'ai appris de nouvelles choses durant cette discussion intéressante, et je t'en remercie.

[koala01]

Le fossé en terme d'expérience qui nous sépare doit être à l'origine de ce désaccord.

Hé oui, l'expérience est la meilleure des écoles

Tu as mis en place des bonnes habitudes de codage pour éviter de provoquer ces bugs (que je vais tenter d'imiter),

En fait, quand tu cherches un tout petit peu, il est très facile de retrouver des règles de codage sur le net, ainsi que leur justifications (une règle édictée sans être justifiée ayant sommes toutes peu de chance d'être suivie parce que simplement non comprise )

Là où l'expérience intervient, c'est qu'elle te permet, surtout, de "faire la part des choses" et de décider de respecter les règles qui sont vraiment importantes, en "laissant de coté" celles qui sont, définitivement, d'un "autre temps" (autre temps, autre moeurs )

et tu utilises des outils pour les détecter. Tu en as l'habitude, cela t'est naturel.

En effet...

Disons que c'est le "petit plus" (en fait, petit par ce qu'il demande de travaille, mais énorme par le temps qu'il peut faire gagner ) qui permet d'éviter de passer des heures à se demander "mais pourquoi ca ne fonctionne plus comme avant"

Ce qu'il faut comprendre, c'est que, bien que le développement soit une activité que l'on pourrait assimiler à quelque chose "d'artistique" (comprends: qui permet de créer de toute pièces quelque chose qui correspond à une vue de l'esprit ), c'est malgré tout une activité qui nécessite une discipline stricte si on veut s'éviter quelques soucis

Je ne pourrais jamais assez te conseiller de faire des tests unitaires ou d'utiliser un système de versions concurrentes, mais, avant même de décider d'utiliser ces outils, la première discipline à acquérir est, sans contexte, celle de choisir correctement le nom de tes fonctions et de tes variables, directement suivie (ou précédée meme ) par celle d'indenter correctement ton code.

Ces deux aspects arrivent vraiment à minimiser très fortement le risque d'erreur

En débutant je me dis : si C++ avait un petit mot clef de plus pour obtenir la bonne portée désirée, alors il n'y aurait même pas à y penser : cela provoquerait une erreur à la compilation.

Je n'y ai jamais réfléchi et, bien que je sois maintenant expérimenté, je n'en ai personnellement jamais ressenti le besoin, même quand j'étais débutant (car il ne faut pas oublier que toute personne d'expérience à commencé débutant, à un moment ou à un autre )

Je serais curieux de savoir si ce comportement désiré est implémenté dans d'autres langages.

J'en serais personnellement surpris, de par le coté impératif propre aux langages de programmation.

Mais bon, ne ne prétend pas non plus connaitre à fond tous les langages, et donc... qui sait

En tout état de cause, je ne crois pas que cela ait jamais posé le moindre problème à qui que ce soit qui apprenait le C++

J'ai appris de nouvelles choses durant cette discussion intéressante, et je t'en remercie.

Mais c'est naturel