Discussion :

[Seabast888]

Bonjour,

Est-ce possible de faire une fonction retournant un pointeur sur un objet ?

Par exemple :

Code :

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

1
2
 
*Objet getMin(Objet *noeud, string el);

Le but étant de pouvoir accueillir cette fonction directement par un pointeur :

Code :

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

1
2
 
Objet *courant = getMin(n,el);

Par exemple, si le pointeur courant pointe sur un noeud, la fonction getMin retournerait directement un pointeur sur un noeud, qui serait le min.

Est-ce que ceci est possible, ou est-ce qu'il y a moyen de faire mieux ?

merci !

[Goten]

T* foo();


Mais bon, faut savoir ce qu'on fait. Si l'objet a été dynamiquement alloué c'est à l'appelant de garantir sa destruction?

Tu peux utiliser une référence (constante) aussi.

[FabTheGeek]

En référence à mon post:
http://www.developpez.net/forums/d83...onst-fonction/

est il possible d'en faire carrément une lvalue comme avec des références?

genre

Code :

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

getMin(n,el)= objet;

[Lavock]

[SUPPRESSION]

[EDIT]
Erf, le précedent post n'est pas l'auteur... Je me douter qu'il y avais un truc bizarre >< !
[/EDIT]

Oui...

=> une référence n'est pas un truc magique. C'est un pointeur figé à sa création... Tout ce qu'on peut faire avec une ref, on peut le faire avec un pointeur (sauf la surcharge d'opérateur).

[Seabast888]

'jour,

Ce n'est pas de mon crue cette fonction qui va vers un pointeur...
Par contre, si je fais comme ça, est-ce que ça fait plus de sens ?

Code :

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

1
2
 
Objet *courant = &getMin(n,el);

En ajoutant une référence, le pointeur pointera vers la référence du résultat de la fonction.
Du moins, je n'ai plus d'erreur d'initialisation!

merci pour votre avis

[Lavock]

Je savais que j'étais pas reveillé...

Bon, l'opérateur "&", c'est pour récupérer l'adresse d'une rvalue... Donc ce que tu met n'as aucun sens...

Sous reserve que ta fonction retourne effectivement une ravlue (pointeur ou référence), tu peux "récupérer" cette objet par adresse (comprendre ref. ou pointeur). Si tu a mis des otpions de compilation style

Code :

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

-pedantic -std=c++03 -wAll

et que rien de rale, c'est que ta fonction renvoie une référence.

Sinon, si tu es sur qu'elle renvoie un pointeur, met les options équivalente. Si ça marche toujours, jette ton compilateur....

[koala01]

Salut,

Ce qui est embêtant, avec le symbole "&", c'est qu'il a quatre sémantique définies et une cinquième libre

Ainsi, il peut s'agir

• du symbole représentant une référence, lorsque tu es dans une déclaration (Type /* const */ & ref /*=lavar */ , Type /* const */ & foo(), void bar( Type /* const */ & ) )
• du symbole "address of" (prise de l'adresse de l'objet pour créer un pointeur) lorsqu'il se rapporte à une rvalue
• du symbole ET logique, lorsqu'il relie deux expressions pouvant être considérées comme valeurs binaires (res = value & mask )
• du symbole ET optimisé (dans le sens où la deuxième expression n'est évaluée que si la première est vraie) lorsqu'il est doublé et qu'il relie deux expressions évaluables comme si elles étaient booléennes ( if (ptr && ptr->next) )
• N'importe quelle sémantique lorsqu'on ne définit pour une classe (boost.serialize lui donne la sémantique d'accès à un flux in ou out, par exemple)

Dans l'exemple que tu donnes ( Objet *courant = &getMin(n,el); ), l'opérateur & s'applique à une rvalue, et tu prend donc "l'adresse de ce qui est renvoyé par getMin".

Si le résultat renvoyé par getMin est déjà un pointeur, tu obtiendra donc un pointeur de pointeur...

T* foo();


Mais bon, faut savoir ce qu'on fait. Si l'objet a été dynamiquement alloué c'est à l'appelant de garantir sa destruction?

Il faut savoir ce que l'on fait, mais ce n'est pas *forcément* à l'appelant de garantir la destruction:

c'est plutôt à l'objet ou à la fonction qui possède le pointeur sur le premier noeud sur lequel tous les autres viennent se "greffer"...

Encore faut il veiller à ne pas détruire l'objet trop top... ni trop tard

L'utilisation du RAII (et surtout de son pendant Ressource Release is Destruciton :p) peut nous donner certaines certitudes sur le sujet

=> une référence n'est pas un truc magique. C'est un pointeur figé à sa création... Tout ce qu'on peut faire avec une ref, on peut le faire avec un pointeur (sauf la surcharge d'opérateur).

Oui si l'on observe le code binaire exécutable créé, mais... non, car la compréhension de ce qu'est une référence devrait se limiter à la sémantique et à la syntaxe, c'est à dire à un domaine où les différences sont bien plus nombreuses que les points communs...

Il faut comprendre qu'un pointeur est un objet, dans le sens où il dispose de sa propre adresse en mémoire, ce qui fait qu'il est possible d'utiliser l'opérateur "address of" pour récupérer... un autre objet dont la valeur représentera... l'adresse du pointeur et obtenir... un pointeur de pointeur, sur lequel il est possible d'utiliser l'opérateur "address of" pour obtenir un pointeur de pointeur de pointeur, et nous pourrions continuer ainsi presque jusqu'à la saint glain glain...

Une référence par contre est un alias de l'objet référencé et n'a, "officiellement" du point de vue du programmeur du moins, pas d'adresse mémoire propre (même si, actuellement, du point de vue du code généré, elle dispose, effectivement d'une place mémoire qui lui est réservée).

Il est donc possible de déclarer une référence sur un pointeur (Type *& refPtr), mais il est par contre impossible de déclarer... un pointeur sur référence (Type &* ptrRef)... ou d'essayer d'en prendre l'adresse.

De plus, syntaxiquement parlant, il y a une différence entre l'utilisation d'un pointeur, qui requière l'utilisation de la fleche "->" ou de l'étoile " * " (utilisée pour sa sémantique d' operateur "pointed by") pour pouvoir accéder au contenu de l'objet pointé, alors qu'une référence se manipulera en utilisant exactement la même syntaxe que si l'on manipulait l'objet d'origine (le plus souvent en utilisant le point "." pour accéder à son contenu, à moins que nous n'ayons justement affaire à... une référence sur un pointeur...), modulo les éventuelles restrictions imposées par le fait que la référence puisse être déclarée constante.

Personnellement j'estime, mais je peux faire fausse route, qu'il est préférable de limiter, dans un premier temps du moins, la compréhension des références au seul domaine de la sémantique et de la syntaxe, afin d'éviter toute confusion entre une référence ( Type /* const */ &) et... un pointeur constant (Type * const )

[Lavock]

Personnellement j'estime, mais je peux faire fausse route, qu'il est préférable de limiter, dans un premier temps du moins, la compréhension des références au seul domaine de la sémantique et de la syntaxe, afin d'éviter toute confusion entre une référence ( Type /* const */ &) et... un pointeur constant (Type * const )

Je pense que cela dépends de si la personne maîtrise le C ou pas... Mais j'avoue, tous ce qui est val/ptf/ref, etc... c'est déjà pas simple. Et ça va être encore plus difficile en c++1x (<- boutade).

D'ailleurs, y a un truc dans la faq pour ça ?
*est partie vérifier*

Le plus proche par juste de "qu'est-ce qu'une réf"... Mais rien sur le c++1x (<- boutade encore).

[koala01]

<snip> Et ça va être encore plus difficile en c++1x (<- boutade).
<snip>
Mais rien sur le c++1x (<- boutade encore).
<snip>

Mais tu n'a rien compris: 0x ou permet d'aller jusqu'à F