Comment afficher le nom d'un variable passée en paramètre d'une fonction ?

Version imprimable

Je voudrait faire quelque chose qui ressemble à ça :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <iostream>
#include <string>
 
void prnt(int var){
  std::cout << "Le nom de ma variable passée en paramètre = " << var << std::endl;
} 
 
int main(void){
  int variable = 3;
 
  prnt(variable);
 
   return 0;
}

16/03/2022, 22h48
koala01

Salut,
Déjà, pourquoi voudrais tu le faire? cela n'a pas vraiment de sens , car ce nom associé à une donnée n'est qu'un identifiant que nous -- pauvres humains -- utilisons pour désigner cette donnée bien particulière parmi l'ensemble des données que nous avons a manipuler, mais que cet identifiant n'a en réalité de sens que pour nous seuls.

Du point de vue du compilateur et de l'ordinateur, ce qui pourrait éventuellement s'obtenir de manière automatique et qui se rapprocherait le plus de l'identifiant de la donnée, ce serait l'adresse mémoire à laquelle la donnée en question se trouve.

Or, pour que ce genre d'information puisse avoir le moindre intérêt de ton coté, il y a tellement de choses à prendre en compte que cela reviendrait à te taper la tête avec un marteau, en disant à celui qui te prend pour un fou que "cela fait tellement de bien quand ca s'arrête".

Peut-être, plus tard, auras tu une bonne raison de vouloir connaitre exactement l'adresse mémoire à laquelle se trouvent certaines de tes données. Tu te rendras alors compte que ce qu'il te faut, c'est un débuggeur, et non simplement un affichage qu'il te faudrait gérer par toi-même ;)

Ensuite, il faut faire attention aux termes utilisés: est-ce le nom de la variable qui est transmise comme argument à la fonction ou le nom du paramètre que tu veux afficher :question:

Cependant, il serait sans doute intéressant de creuser un peu d'avantage sur cet aspect sémantique que représente la différence entre un argument et un paramètre. Ce sera pour une autre fois, si tu en émet le souhait ;)
16/03/2022, 23h09
hary66
J'avais une class Point.
avec des points p1, p2, ....
Point p1(2, 5);
Point p2(5, 1);

Je voulais une fonction

Code:

void afficherPoint(Point p)

.

Et que
Code:

1 2 afficherPoint(p2); afficherPoint(p1);
affiche :
p2(5, 1)
p1(2, 5)

C'est juste pour exercice et se faire la main.

Citation:

Envoyé par koala01

Déjà, pourquoi voudrais tu le faire? cela n'a pas vraiment de sens

Pour faire du debugging/ logging assez poussé :mrgreen:

C'est très très très limité, mais avec le pragma tu as l'opérateur # pour avoir le nom du paramètre et ## pour concaténer.
Pour + d'explications, :google:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 #include <iostream> #include <string> #define STR(X) #X void prnt(int var){ std::cout << "Le nom de ma variable passée en paramètre: " << STR(var) << std::endl; } int main(void){ int variable = 3; std::cout << "Le nom de ma variable: " << STR(variable) << std::endl; prnt(variable); return 0; }

17/03/2022, 01h52
koala01
Citation:
Envoyé par hary66

J'avais une class Point.
avec des points p1, p2, ....
Point p1(2, 5);
Point p2(5, 1);

Je voulais une fonction

Code:

void afficherPoint(Point p)

.

Et que

Code:

1 2 afficherPoint(p2); afficherPoint(p1);

affiche :
p2(5, 1)
p1(2, 5)

C'est juste pour exercice et se faire la main.
Ce qu'il faut comprendre, c'est que les fonctions sont de véritable "boites noires".

Tu as éventuellement "une fente" dans la boite pour pouvoir "y glisser quelques informations" qui seront nécessaires pour que la fonction puisse faire son taf (les paramètres / arguments) et, tout aussi éventuellement, une fente pour pouvoir en récupérer le résultat (la valeur de retour).

Mais, hormis ces deux fentes éventuelles, il faut comprendre qu'absolument tout se qui se fait dans la boite est strictement isolé du monde extérieur. il n'y a RIEN qui puisse entrer ou sortir de la boite. Au mieux, l'utilisateur de la boite en question peut il ... espérer que la boite fera correctement son travail ;)

Si bien que, quand ut as une fonction qui en appelle une autre, et que cette deuxième fonction en appelle une troisième, tu as, littéralement "une boite, dans une boite, dans une boite". Et à chaque fois que tu rencontre les cotés d'une boite dans la boite qui t'intéresse, c'est un endroit où les données contenues dans la boite que tu observe n'ont pas accès.

C'est d'ailleurs pour cela que ces deux fentes ont été prévues: l'une pour nous permettre de fournir les données qui permettront à la fontion appelée de fonctionner, et l'autre pour nous permettre de ... récupérer le résultat de la fonction appelée. Autrement, ben, nous aurions sans doute quelques soucis à faire communiquer les différentes fonctions entre elles.

Si donc tu es au niveau de la fonction afficherPoint, la seule information "venue de l'extérieur" que tu connaisse, c'est que tu dispose d'une donnée de type Point, et que cette donnée est identifiée comme étant p.

Tu ne sais ABSOLUMENT RIEN DE PLUS. Et tu n'as ABSOLUMENT PAS à en savoir plus.

D'ailleurs, si cela se trouve, ce n'est même pas toi qui va utiliser ta fonction afficherPoint. Si ca se trouve, c'est moi -- ou foetus, qui a eu le malheur de nous rejoindre :D -- qui allons utiliser cette fonction

Sauf que nous, ben, on n'était pas à coté de toi quand tu as écrit cette fonction. On n'a donc aucune raison de savoir "ce qui se passe dans la boite noire".

Les seuls indices dont nous disposons, foetus et moi-même, ce sont :
- le nom de la fonction: on se doute bien qu'elle ne va pas faire des baignets :D
- ce qu'il faut lui "donner à manger" pour qu'elle fonctionne correctement: elle a besoin d'un point
Seulement, si cela se trouve, on ne va pas faire appel à ta fonction avec un point "préexistant" nommé p1 ou p2, mais avec un point appelé coordonneeDeLElysee ou même, en ayant créé un point qui n'existera que ... le temps de permettre à ta fonction de faire son taf et qui n'existe nulle part ailleurs.

Il est d'ailleurs même fort possible que l'on décide de faire appel à ta fonction depuis une fonction qui est à des "années lumières" de la fonction main.

Or, tu n'as aucun moyen de savoir tout cela. Pire encore: en fait, tu n'en a absolument rien à f...re.

En fait, ce sur quoi je veux insister ici, c'est le fait que tu n'est le développeur d'une fonctionnalité -- quelle qu'elle soit -- que le temps strictement nécessaire à écrire le code correspondant et à t'assurer qu'elle effectue correctement le taf qu'elle est sensée effectuer. Bon, et éventuellement, à corriger le code s'il pose le moindre problème.

Mais, une fois que cette étape est franchie, tu ne peux plus te considérer comme "le développeur" de cette fonctionnalité. Car tout ce que tu pourras encore en faire, c'est ... l'utiliser, comme les dix personnes qui travaillent dans ton équipe, ou comme les deux pelés qui répondront sur un forum.

Et tu dois donc te considérer à ce moment là comme ... un utilisateur lambda, qui ne sait absolument pas ce qui se passe "en interne" dans la fonctionnalité, et qui peut juste espérer que ... cette fonctionnalité effectue correctement le travail que l'on attend de sa part.

C'est d'autant plus vrai que le temps passe. Que tu peux très bien laisser ton projet "de coté" pendant trois mois, six mois ou un an avant de "revenir dessus" pour tout plein de bonnes raisons.

Or, dans trois mois, six mois ou un an, tu auras eu largement le temps d'oublier toutes les raisons qui t'ont incité à écrire le code correspondant à ta fonction afficherPoint de la manière dont tu l'a écrit aujourd'hui. Et pour éviter d'avoir à "foutre ce code à la poubelle" et à devoir le recommencer, ben, tu vas sans doute décider de ... l'utiliser, même si tu ne sais "plus trop bien" (voire plus du tout) ce qu'il était sensé faire, en dehors des indices que foetus et moi-même avons utilisés ;)

Citation:

Envoyé par foetus

Pour faire du debugging/ logging assez poussé :mrgreen:
(snip)

Oui, je sais... Je crains cependant que ce ne soit pas vraiment l'objectif direct de notre ami.

Je suppute donc qu'il vaut largement mieux lui permettre de comprendre comment se passer de ce "besoin" (qui n'en est pas vraiment un, qui est juste mal exprimé) que de commencer à lui indiquer les techniques vaudous avancées :D

Nope, foetus, ton bout de code ne fait pas ce que je veux !

Je voulais un affichage comme rendu par ce code :

Code:

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
38
39
40
41
42
43
44
#include <iostream>
//#include <string>
using namespace std;
 
class Point
{
private:
    int x, y, z;
    string Name;
 
public:
    Point(string name, int a, int b, int c) : Name{name}, x{a}, y{b}, z{c} {}
    //setteurs:
    void Name_(string name) { Name = name; }
    void x_(int a) { x = a; }
    void y_(int b) { y = b; }
    void z_(int c) { z = c; }
    //accesseurs
    string Name_() const { return Name; }
    int x_() const { return x; }
    int y_() const { return y; }
    int z_() const { return z; }
};
 
//Surcharge d el'opérateur <<
ostream &operator<<(ostream &COUT, Point &point)
{
    COUT << point.Name_() << "(" << point.x_() << ";" << point.y_() << ";" << point.z_() << ")"  << endl;
    return COUT;
}
 
int main()
{
    Point p1("p1", 2, 4, 7);
    Point p2("p2", 2, 3, 4);
    Point p3("p3", 10, 20, 56);
 
    std::cout << "Liste des points :\n";
    std::cout << p1;
    std::cout << p2;
    std::cout << p3;
 
return 0;
}

17/03/2022, 10h44
dalfab

Le code que tu indiques ne correspond pas pas ta question.

Dans ce code, un texte est stocké dans l'objet et ce texte est ensuite réutilisé. Si on prend la ligne Point p1("p1", 2, 4, 7);, le texte associé à l'objet p1 est "p1", on aurait aussi bien pu écrire:

Code:

Point p1("Le point n°1", 2, 4, 7);

A aucun moment le nom de la variable p1 n'est transformé en texte, c'est ce qui t'a été expliqué.
18/03/2022, 03h02
foetus

Citation:

Envoyé par hary66

Nope, foetus, ton bout de code ne fait pas ce que je veux !

Comme l'a dit @koala01 et @dalfab, ce que tu veux faire, tu dois le faire manuellement.
Effectivement, mettre 1 nom dans 1 classe, tout le monde l'a fait (1 nom ou 1 valeur énumérée)

Mais maintenant, pose-toi la question suivante : quel est l'impact de cet ajout dans ton code ?
Dans ton code, tu vas avoir 1 chaîne de caractères pour chaque point :mrgreen: :aie:

Avec une macro, on peut faire qq chose :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 #define CREATE_POINT(variable, x, y, z) auto variable = Point(#variable, (x), (y), (z)) #include <iostream> int main() { CREATE_POINT(p1, 2, 4, 7); CREATE_POINT(p2, 2, 3, 4); CREATE_POINT(p3, 10, 20, 56); std::cout << "Liste des points :\n"; std::cout << p1; std::cout << p2; std::cout << p3; return 0; }
Code:

1 2 3 4 Liste des points : p1(2;4;7) p2(2;3;4) p3(10;20;56)
Je ne sais pas quel est l'intérêt d'un tel code, toutefois.

Accessoirement, on est très loin de l'idée du code d'origine, qui ressemble plus à une fonctionnalité de débogage avancée. Ce genre de code est très complexe à faire en C++ car les noms de variables n'existent plus après la compilation, au contraire de langages comme Python par exemple.

On peut ruser avec des macros (toujours elles) :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 #include <iostream> #define PRINT_VARIABLE(variable) std::cout << "Le nom de ma variable passee en parametre = " << #variable << " valeur = "<< variable << '\n'; int main() { int variable = 3; PRINT_VARIABLE(variable); std::string myString = "hello, world"; PRINT_VARIABLE(myString); return 0; }
Code:

1 2 Le nom de ma variable passee en parametre = variable valeur = 3 Le nom de ma variable passee en parametre = myString valeur = hello, world
Pour aller plus loin dans l'obtention du nom d'un truc, tu peux regarder cette lib : https://github.com/Neargye/nameof

@Bktero, Ton premier bout de code ne compile pas.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 > Executing task: C/C++: g++ générer le fichier actif < Démarrage de la génération... /usr/bin/g++ -fdiagnostics-color=always -g /home/harold/C++/pragma/pragma.cpp -o /home/harold/C++/pragma/pragma /home/harold/C++/pragma/pragma.cpp: In function ‘int main()’: /home/harold/C++/pragma/pragma.cpp:1:57: error: ‘Point’ was not declared in this scope 1 | #define CREATE_POINT(variable, x, y, z) auto variable = Point(#variable, (x), (y), (z)) | ^~~~~ /home/harold/C++/pragma/pragma.cpp:5:5: note: in expansion of macro ‘CREATE_POINT’ 5 | CREATE_POINT(p1, 2, 4, 7); | ^~~~~~~~~~~~ La génération s'est achevée avec une ou plusieurs erreurs.
Pour le second exemple, oui ça fonctionne et renvoie selon mon intention initiale.

@foetus, une fois dans la fonction, le STR(X) ne renvoie pas le nom de la variable ! L'utilisation directe, puis l'utilisation dans une fonction en exemple était elle intentionnelle pour montrer ce comportement ?

18/03/2022, 15h33
Bousk

Y'a-t-il une vraie raison de vouloir faire ça ?
C'est généralement inutile dans 99% des cas.
Ça sent au mieux l'Heisenbug cette histoire.
18/03/2022, 16h40
hary66

La seule raison est que je pratique des petits exercice et il me vient des idées de complément qui me permettent de tester quelques trucs qui me viennent à l'esprit.

Je note que mon idée n'en est pas une, donc je vais me concentrer sur autre chose.

Mais comme je m'amusais à manipuler les références, les pointeurs etc,..., je voulais voir ce qu'il y avait dans chaque "trucs", ce qui m'avait amener à cette question.:D
19/03/2022, 18h46
foetus

Citation:

Envoyé par hary66

Mais comme je m'amusais à manipuler les références, les pointeurs etc,..., je voulais voir ce qu'il y avait dans chaque "trucs", ce qui m'avait amener à cette question.:D

En informatique cela s'appelle la réflexion - lien wikipedia en français 1 peu succinct
Manque de bol :aie: le C/ C++ sont les moins fournis. En C++, il y a le RTTI ou les templates, mais c'est assez "complexe".

Citation:

Envoyé par hary66

@foetus, une fois dans la fonction, le STR(X) ne renvoie pas le nom de la variable ! L'utilisation directe, puis l'utilisation dans une fonction en exemple était elle intentionnelle pour montrer ce comportement ?

Oui intentionnelle :mrgreen: Je n'utilise pas cette fonctionnalité du #pragma. Mais en testant, le nom affiché est celui du paramètre et non pas celui de la variable passée en paramètre.

Citation:

Envoyé par hary66

La génération s'est achevée avec une ou plusieurs erreurs.

C'est 1 des problèmes des macros : c'est 1 remplacement à trou. Donc, s'il n'y a pas les bons #include/ définitions/ déclarations, cela ne compile pas. C'est logique.
21/03/2022, 09h50
Bktero

Citation:

Envoyé par hary66

@Bktero, Ton premier bout de code ne compile pas.

Il faudrait peut-être que tu rajoutes ta classe Point, que tu as fourni dans un message précédent...