Discussion :

[senvedgi]

bonjour à tous,
La fonction FcIntStr,dont code ci-dessous, ne répond pas à mon attente.
Je voudrais une sortie sous les lignes Ch ou CA de préférence à celle de St.

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
 
 
//essai 
//#include <string>
#include <iostream>
#include <sstream>  
//#include <fstream>
 
using namespace std;
 
string FcIntStr(int NbA,string ChA,int fcvue)
{//29/12/11/22h
//IntVerStr=FcIntStr(nb,ch,fcvue); 
     ostringstream ossNbA;
     ossNbA<<NbA;
     ChA=ossNbA.str();
return ChA;      
}//29/12/11/22h
 
int main()
{   
    int fcvue=0;
    cout<<"essai int vers string"<<endl; 
    int nb=15;
    string Ch;
    string ChA;
    string IntVerStr;
 
    IntVerStr=FcIntStr(nb,Ch,fcvue);
 
    cout<<"St "<<IntVerStr<<endl;
    cout<<"It "<<nb <<endl;
    cout<<"CA "<<ChA<<"*"<<endl;//pourquoi vide?  
    cout<<"Ch "<<Ch <<"*"<<endl;//pourquoi vide?
 
    cout<<"<E>";cin.get();
}

La fonction doit être mal écrite()?
Merci pour cette étude.

[3DArchi]

Salut,
ChA est vide car elle n'est pas initialisé autrement qu'à la construction. Ne pas confondre ChA dans la fonction main et ChA dans la fonction FcIntStr. Bien qu'elles aient le même nom, ce sont bien deux variables différentes car sises dans des 'portées' (~blocs) différents.

Ch est vide car la fonction FcIntStr prend son argument par valeur. Cela signifie qu'il fait une copie de l'argument avant d'entrer dans la fonction. Toute modification dans la fonction se faisant sur la copie, cela n'aura pas d'impact sur l'argument passé en paramètre. Il faudrait utiliser un passage par référence si tu voulais modifier l'argument :

Code :

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

1
2
3
4
5
6
7
8
string FcIntStr(int NbA,string &ChA,int fcvue)
{//29/12/11/22h
//IntVerStr=FcIntStr(nb,ch,fcvue);
     ostringstream ossNbA;
     ossNbA<<NbA;
     ChA=ossNbA.str();
return ChA;
}//29/12/11/22h

[senvedgi]

Bonjour et merci pour ce petit cours de C++/dev-cpp.
J'ai d'autres fonctions du même tonneauJe vais les transformer avec le
dopant "&".
Merci beaucoup(..et rapide!)

[koala01]

Salut,

En fait, ta fonction renvoie une chaine de caractères et je ne vois donc pas pourquoi tu voudrais que la chaine de caractères passée en argument soit modifiée

Je ne dis pas que ce n'est pas juste que de faire en sorte que la chaine de caractères passée en argument soit modifiée, car cela peut avoir un sens, mais, ce que je dis, c'est que le nom de ta fonction et celui des paramètres n'est pas suffisamment bien choisi pour nous permettre de nous faire une idée de l'opportunité qu'il peut y avoir à ce que ce soit le cas

Je m'explique:

La logique que tu places dans ta fonction est sensée modifier ChA et renvoyer ChA sous la forme de valeur, mais, est-ce vraiment utile

En effet, si tu récupères la chaine renvoyée par ta fonction dans une autre variable que celle qui est passée comme étant ChA, tu auras deux variables qui auront exactement la même valeur : la variable passée en tant que paramètre et celle qui aura récupéré le retour de la fonction...

Qu'est ce qui pourrait justifier ce fait

Tu as, en effet, deux solutions:

Soit, tu te dis que tu veux modifier une variable qui existe dans la fonction appelante (cela peut avoir un sens, s'il est question de concaténer des données ) et, à ce moment là, tu n'as pas besoin de la valeur de retour, avec un code 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
 
void foo(int NbA,string &ChA)
{
    std:::stringstream ss;
    ss<<NbA<<ChA;
    ChA == ss.str();
}
int main()
{
    std::string truc="machin";
    int basard = 10;
    foo(basard, truc);
    /* truc="10machin" ;) */
}

Soit tu te dis que, ce qui t'intéresse, c'est le retour de ta fonction:

Code :

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

1
2
3
4
5
6
7
8
9
std::string bar(int NbA,std::string const &ChA) // le fait de passer la chaine
                                     // sous la forme d'une référence constante évite
                                     // la copie de la chaine, mais empêche qu'elle soit
                                     // modifiée
{
    std:::stringstream ss;
    ss<<NbA<<ChA;
    return ss.str();
}

et tu peux alors décider soit de récupérer le résultat dans une autre variable, soit de le récupérer dans une variable existante:

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()
{
    std::string truc="truc";
    int basard = 10;
    truc=bar(10,truc); // oui oui, ca marche :D : truc = "10truc"
    /* OU OU OU OU */
    std::string brol="brol";
    int bidule = 20;
    std::string recup=bar(bidule, brol);
    /* brol = "brol", recup = "20brol" */
    /*...*/ 
    return 0;
}

Par contre, le fait de mélanger les deux est, très certainement, le meilleur moyen d'avoir un "effet de bord" aux effets des plus désagréables et difficiles à retrouver...

Imagine un peu les fonctions

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
std::string bar(int i, std::string & str)
{
    std:::stringstream ss;
    ss<<NbA<<str;
    str== ss.str();
    return str;
}
void foo(std::string & str)
{
    int i = 10;
    /*... */
    std::string temp = bar(i, str);
    /* ici, on travaille avec temp  ;) */
}
int main()
{
    std::string truc="truc";
    /* 15 instructions */
    foo(truc);
    /* 15 instructions */
   /* je voudrais que truc vaille "10truc" :D */
   bar(10,truc);
   std::cout<<truc<<std::endl; //Mais pourquoi truc, qui est sensée valoir
                               // "10truc" vaut elle "1010truc" ????
   return 0;
}

Ici, le cas est relativement simple, et il apparaitra (relativement) vite que truc vaut déjà "10truc" bien avant que tu n'appelles bar() dans main() (à cause de l'appel à foo() ), mais c'est typiquement le genre de choses, lorsque tu as des fonctions qui appellent des fonctions qui appellent des fonctions qu'il te sera très difficile de repérer, surtout si tes fonctions sont un tant soit peu complexes

Moralité : évites toi bien des soucis et évite qu'une valeur de retour soit identique à la nouvelle valeur d'un argument passé en entrée / sortie

[senvedgi]

Merci pour ces hautes et logiques considérations qui ont une grande valeur.
Le & ajouté à la "variable" sort me suffit.Je vais veiller à la construction des noms des variables.
Bien noter que j'ai modifié sort en sortie car sort est un mot réservé....tri en français.
Merci à tous.

[koala01]

As-tu seulement compris tout ce que ce petit "&" implique et le sens de mon intervention

Mon intervention avait pour but de te faire prendre conscience que tu est de toute évidence face à un problème de conception dés le moment où tu envisage de faire en sorte qu'une variable passée en argument soit modifiée d'un coté tout en récupérant le résultat de cette modification par la valeur de retour de la fonction!!!

Comme l'indiquaient les portions de code que j'ai fournies (et surtout les commentaires que j'ai pris la peine de rajouter ), tu risques vraiment de te retrouver avec des valeurs qui peuvent te sembler incohérentes, simplement parce que l'appel d'une fonction aura eu pour résultat d'appeler une fonction qui apportera des modifications auxquelles tu ne penses peut etre pas

Le fait qu'une fonction modifie une variable qui lui est passée en argument est ce que l'on appelle couramment un "effet de bord" et il s'agit de se méfier comme de la peste de ces derniers, parce qu'il est particulièrement difficile d'avoir un aperçu clair et précis de la manière dont il va se répercuter dans le code

De plus, le caractère "&" n'est pas un caractère magique intervenant dans une quelconque pratique vaudou!!

C'est le symbole qui, utilisé sous la forme présentée ici, indique que l'on travaille avec une référence sur un objet.

Le fait de travailler avec des références présente énormément d'avantages, mais nécessite aussi d'aborder les choses avec la plus grande discipline possible:

Du fait que l'on travaille en réalité avec un alias de l'objet référencé, il faut être conscient que tout ce qui arrive à la référence arrivera en réalité à l'objet référencé et que l'idéal reste donc de toujours éviter les effets de bord en déclarant constant tout ce qui peut l'être, justement pour éviter qu'une modification n'aille prendre effet sur quelque chose que l'on n'imagine peut etre pas

Je ne peux donc que t'inciter à méditer sur ce que je viens d'écrire et à prendre en compte ces remarques, meme si c'est sur un "petit projet", ne serait ce que pour t'habituer directement à faire du travail correct