Discussion :

[panthere noire]

Hello

je sais qu'une référence pointe sur une variable , donc on ne peux pas y mettre une valeur directement.

mai c est là que sa me dérange, car quand des fonction s'appelle parfois on pour éviter de déclarer une nouvelle variable juste pour la passer en paramètre

bon un petit bout de code mange pas de pain

Code :

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

1
2
3
4
5
6
7
8
9
10
 
la fonction:
 
bool maclasse::ouverture(std::string &chemin_donnee)
{
 
}
depuis le main:
std::string &reference_chemin_donnee ="./fichier"
maclasse.ouverture(reference);

j'aurais voulu depuis le main avoir la possibilité de mettre
maclasse.ouverture("./fichier");

mai c est possible (a ma connaissance ) que si la référence est supprimée ?
la raison pour la qu'elle je voudrai utiliser des référence c'est que sa ne recopie pas les donnée. surtout que pour mon cas sa proviens d'une base de donnée c'est donc non négligeable.

Merci d'avance

[Invité]

Bonsoir,

"./fichier" est un char[10].
La méthode ouverture prends un paramètre un std::string.
Dans ce cas de figure, il y aura toujours construction d'un objet pour que la méthode puisse travailler avec.

[panthere noire]

edit : grilled, je repasse plus tard pour une réponse plus apropriée.

[koala01]

Salut,

Si tu ne veux pas devoir déclarer une variable rien que pour pouvoir la transmettre à une fonction, c'est sans doute parce que tu souhaite pouvoir utiliser... une variable anonyme temporaire, autrement dt, une variable qui n'existera que pendant la durée de l'exécution de la fonction et à laquelle tu n'as pas besoin de faire appel en dehors de la fonction appelée, ce qui te permet de ne pas lui donner de nom.

Cela implique qu'il n'y a, en définitive, aucune raison pour permettre à la fonction appelée de modifier cette variable, étant donné que tu ne pourras de toutes manières pas utiliser la valeur modifiée dans la fonction appelante.

C'est la raison pour laquelle le langage autorise la création de variable anonyme temporaires à la condition que ce soit à l'occasion soit d'un passage d'argument par valeur, soit à l'occasion d'un passage d'argument par référence constante.

Seulement, voilà... tu as surement déjà compris tous les inconvénients du passage par valeur, et tu comprendra donc tous les avantages qu'il y aura à passer ces arguments sous la forme de référence constante .

[panthere noire]

merci pour les complément d'information.

Flob90:
la nouvelle norme est effectivement en vigueur. mai les distribution stable par exe. debian lenny on pas le compilateur qui va avec, je vai donc me tenir a du c++ standard pour le moment.
Mai c est pas tomber dans l'oreile d'un sourd

burndev:

je doit encore creuser un peux le sujet donc je reste un peux vague sur ma réponse
il me faut un peux pratiquer pour comprendre le principe , même s'il est simpel.

koala01
effectivement j'avais pas penser a la référence constante je vai donc opter pour cette solution

[koala01]

Fait attention cependant au fait que:
soit, tu dois avoir un constructeur quo pourra faire office d'opérateur de conversion pour ta classe (c'est le cas de la classe std::string, dont un des constructeur accepte un const char* et qui permet d'appeler foo("nom_du_fichier") )
Soit tu devra implicitement invoquer un constructeur particulier pour ta classe:

Code :

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

1
2
/*soit la fonction*/
void foo(UnType const & t);

si "UnType dispose d'un constructeur ne prenant qu'un seul argument (allez, par exemple un int) tu peux parfaitement envisager l'appel sous une forme proche de

Code :

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

1
2
3
4
5
6
int main()
{
    int i;
    /*calculer i */
    foo(i);
}

Si UnType dispose d'un constructeur ne prenant pas d'argument, l'appel se fera sous la forme de

Code :

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

1
2
3
4
int main()
{ 
    foo(UnType()); // appel explicite du constructeur
}

et, enfin, si UnType dispose d'un constructeur prenant plusieurs arguments, ou déclaré explict, tu peux aussi invoquer directement ce constructeur:

Code :

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

1
2
3
4
5
int main()
{
    void foo(UnType(arg1, arg2, arg3));
    void foo(Untype(arg)); // si constructeur déclaré explicit ;)
}

Mais, si tu respecte ces quelques règles, tu devrais pouvoir t'en sortir

[Flob90]

Seul mon troisième exemple était du C++1x, le reste était du C++03, le premier montrais le problème, et le deuxième une solution avec les références constante.

[burndev]

salut

une référence est l'alias d'un objet ou d'une variable.

exemple du passage par référence d'un string 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
 
#include <iostream>
#include<string>
using namespace std;
 
void methodeModif(std::string &ref);
 
int main()
{
    std::string  objString = "mon objet string";
 
    cout << "avant modif :" << objString << endl;
 
    methodeModif(objString);
 
    cout << objString << endl;
    return 0;
}
 
void methodeModif(std::string &ref)
{
    ref += " modifier";
}

si tu veux que le passage par référence ne puisse être modifier, tu peux le déclarer ton paramètre const

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
 
#include <iostream>
#include<string>
 
using namespace std;
 
void methodeModif(const std::string &ref);
 
int main()
{
    std::string  objString = "mon objet string";
 
    cout << "avant modif :" << objString << endl;
 
    methodeModif(objString);
    methodeModif("test");
 
    cout << objString << endl;
    return 0;
}
 
void methodeModif(const std::string &ref)
{
    cout << ref << " modifier" << endl;
    ref += " modifier"; //Erreur paramètre constant
}

bon courage

[Flob90]

Le problème que tu soulèves est celui de l'utilisation de variable temporaire lorsqu'une référence non-constante est attendue.

Ce problème est corrigé en C++1x avec les rvalue reference

Code :

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

1
2
3
4
5
 
int goo(){return 0;}
void foo(int&){} //lvalue reference sur un int
 
foo(goo()); //ne compile pas

Code :

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

1
2
3
4
5
 
int goo(){return 0;}
void foo(const int&){} //lvalue reference constante sur un int
 
foo(goo()); //compile

Code :

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

1
2
3
4
5
 
int goo(){return 0;}
void foo(int&&){} //rvalue reference sur un int
 
foo(goo()); //compile

La nouveauté des rvalue reference vient avec la notion de sémantique de mouvement, qui permet pas mal de nouvelle chose, je te laisse chercher sur internet pour voir les possibilités (une séries d'articles sur C++Next en particulier).