in out parameter

Bonjour tous le monde, je développe un parser C++, donc j'ai besoin de comprendre la syntaxe d'abord, et tous les cas possible pour ecrire cette syntaxe :roll:

pouvez-vous m'aider de savoir comment peut-on déclarer les in/out parameter (tous les cas possible), et s'il y'a un document ça sera mieux

j'ai trouvé ce lien qui explique bien, mais je voulais savoir es-ce qu'on peut ajouter un specifier (modifier) avant ou après les 2 mot clé "in" ou "out"

parce que dans ma grammaire, on trouve

Specifieropt Type Specifieropt Parametre

ou je dois ajouter les mot clés in et out ?!!

Cordialement

Salut

En C++, les paramètres peuvent être passés:

1. par valeur
2. par pointeur
3. par référence

I - Le passage par valeur occasionne la copie de l'objet passé en paramètre, et les éventuelles modifications apportées au paramètre ne sont pas répercutées sur l'objet d'origine.

C'est donc un paramètre "in".

II-Le passage par pointeur transmet "l'adresse à laquelle se trouve" l'objet qui nous intéresse.

Si on modifie "ce qui est pointé par" le pointeur, on modifie l'objet d'origine.

C'est donc un paramètre "in / out".

III-Le passage par référence va transmettre "un alias" de l'objet d'origine.

Si l'on indique rien, il est possible de modifier l'argument, et de répercuter les modifications sur l'objet d'origine. C'est donc un paramètre "in / out "

Si on ajoute le mot clé const, nous passons un alias constant de l'objet d'origine. Le compilateur refusera alors toute tentative de modification du paramètre, et, par conséquent, de l'objet d'origine.

Comme il n'est pas possible de modifier une rérférence constante, nous avons affaire à... un paramètre "in".

Si l'on ajoute le mot clé volatile, on signale au compilateur que l'objet est susceptible d'être modifié par un accès concurrent entre deux accès durant la fonction.

Ce n'est pas à proprement parler un paramètre in/out, mais il peut être modifié par un autre thread, par exemple.

Enfin, il est possible de déclarer le paramètre comme constant volatile, indiquant que l'objet ne sera pas modifié, mais que plusieurs threads sont susceptibles d'y accéder

La déclaration d'un paramètre peut prendre deux formes:

Code:

---

1 2 3

type < const / volatile > < pointeur / référence > type < const / volatile > < pointeur / référence > identifiant

---

la premiere forme ne pouvant être utilisé que lorsque l'on n'a pas besoin d'accéder au paramètre (déclaration de la fonction dans un fichier d'en-tête ou fonction lançant directement une exception, par exemple).

La seconde devant être utilisé si l'on doit accéder au paramètre.

Cependant, si la deuxième forme est utilisées et que l'on ne fait jamais appel au paramètre, certains réglages du compilateurs font qu'il nous envoie un avertissement proche de "attention 'param' est défini mais jamais utilisé "

Enfin, il faut savoir que la règle générale pour les mots clés const et volatile est de s'appliquer à ce qui les précèdent directement.

Ainsi le mot clé const dans le code suivant

Code:

---

Type const &

---

s'applique à Type, alors que dans le code

Code:

---

Type * const

---

il s'applique... à la marque de pointeur

Mais il y a une exception : si le mot clé const (ou volatile) n'est précédé par rien, il s'applique alors à ce qui le suit directement.

Ainsi, les codes

Code:

---

1 2	const Type & const Type *

---

et

Code:

---

1 2	Type const & Type const *

---

sont-ils respectivement identiques

Citation:

---

Envoyé par koala01

....
Ainsi, les codes

Code:

---

1 2	const Type & cont Type * //<== Coquille ici >< !

---

---

Le lien semble être une proposition pour c++0x, qui, à ma conaissance, ne sera pas adopté. D'ailleurs, je n'en avais jamais entendu parler...

[edit totalement hs]
D'ailleurs vous avez jamais remarquez que c'est anti-logique la façon de faire. Style

Code:

---

type const * const machin

---

Si on applique la règle du "avant", alors le type est constant (traduction littéraire, on ne peux pas changer de type ???) et l'étoile, donc le pointeur, est constant.

Une écriture "logique", ou plutôt instinctive, aurait été

Code:

---

type * const machin const

---

Ou alors de dire que justement, il s'applique au mot après (les mot const aurait alors l'inverse des signification qu'ils ont actuellement).

Mais bon, la première et pénible car il faudrait tout le temps nommé la variable, et la seconde manque toutefois d'une certaine esthétique...

Ben oui, c'est moche

Code:

---

Type & const

---

et ça fait pas de jeu de mot >< !

Citation:

---

Envoyé par Lavock

Le lien semble être une proposition pour c++0x, qui, à ma conaissance, ne sera pas adopté. D'ailleurs, je n'en avais jamais entendu parler...

---

Non, c'est la regle...

int const & i es strictement similaire à const int & i, et, char const * est normalement similaire à const char * car l'interprétation se fait de droite à gauche... Sauf si rien ne précède le mot clé...

Par contre, il y a une différence entre char const * et char * const, le premier représentant un pointeur sur caractère(s) constant(s), le second représentant un pointeur constant sur caractère(s) (pas forcément constant(s) )

merci pour cette explication :ccool:

Citation:

---

Envoyé par koala01

En C++, les paramètres peuvent être passés:

1. par valeur
2. par pointeur
3. par référence

La déclaration d'un paramètre peut prendre deux formes:

Code:

---

1 2 3

type < const / volatile > < pointeur / référence > type < const / volatile > < pointeur / référence > identifiant

---

---

d'après cette explication, je comprend qu'on a pas un mot clé en C++ qui s'appel IN/OUT ?:roll:

mais j'ai trouvé un exemple qui contient :

Code:

---

1 2 3 4 5

void CApplicationOptions::Clone(IN OUT CApplicationOptions* pApplicationOptions) { memcpy(pApplicationOptions,this,sizeof(CApplicationOptions)); }

---

:calim2:

Citation:

---

Envoyé par koala01

Non, c'est la regle...

---

Tu es allé sur le lien ? perso, je ne connais pas de in/out specifier >< !

[Edit] Heu, la coquille, c'est le s manquant hein !

Citation:

---

Envoyé par Lavock

Tu es allé sur le lien ? perso, je ne connais pas de in/out specifier >< !

---

au temps pour moi...

Je ne parlais pas du lien, mais du mot clé const et de sa signification en fonction dela place qu'il occupe...

in/out specifier a peut être effectivement été proposé pour C++0x, mais n'est, quoi qu'il arrive, pas utilisable avec la norme actuelle

Citation:

---

Envoyé par koala01

Je ne parlais pas du lien, mais du mot clé const et de sa signification en fonction dela place qu'il occupe...

---

Je suis bien d'accord avec ça, juste que dans l'absolue, je trouve ça "moyen" le faite que spécifié un "type constant" se traduit par une "variable constante". C'est pas "naturelle". Mais c'était juste un gros HS >< !

Citation:

---

Envoyé par mima_mine

merci pour cette explication :ccool:


d'après cette explication, je comprend qu'on a pas un mot clé en C++ qui s'appel IN/OUT ?:roll:

---

Pas dans l'état actuel des choses, en tout cas...

Citation:

---

mais j'ai trouvé un exemple qui contient :

Code:

---

1 2 3 4 5

void CApplicationOptions::Clone(IN OUT CApplicationOptions* pApplicationOptions) { memcpy(pApplicationOptions,this,sizeof(CApplicationOptions)); }

---

:calim2:

---

Le fait qu'ils soient écrit en majuscules me fait penser à des symboles définis par une directive préprocesseur...

Il faudrait sans doute trouver le #define correspondant, mais, à mon sens, c'est un ajout fait par la boite qui a créé le code.

Et il n'est pas exclus (bien que je ne fasse que le supputer ici) que ces deux symboles soient simplement défini à... rien... uniquement pour permettre au lecteur de se rendre compte que le paramètre passé est destiné à modifier l'objet d'origine ;)

Citation:

---

Envoyé par Lavock

Je suis bien d'accord avec ça, juste que dans l'absolue, je trouve ça "moyen" le faite que spécifié un "type constant" se traduit par une "variable constante". C'est pas "naturelle". Mais c'était juste un gros HS >< !

---

[pour clore le HS ] ben, comment lis tu "à haute voix" et en "bon français" le code

Code:

---

int const i=10;

---

Pour moi, cela se lit "i est un objet constant de type int auquel on donne la valeur 10" vu que l'on a ici deux expressions séparées par l'opérateur = ...

Dés lors, le code

Code:

---

int const * j = &i;

---

serait, pour ma part, lu sous la forme de "j est un pointeur vers un objet constant de type int auquel on donne... l'adresse de i" :D et qui serait différent de

Code:

---

int * const k = & i;

---

que je lirais sous la forme de "k est un pointeur constant vers un objet de type int auquel on donne l'adresse de i"

et cela marche aussi très bien avec les références:

Code:

---

int const & ref = i;

---

se lisant "ref est l'alias d'un objet constant de type int se référant à i"

Etant attendu que le code

Code:

---

int & const ref2 = i;

---

n'a aucun sens (et est d'ailleurs interdit par le langage :P )

Mais bon, j'ai tendance à être verbeux dans ma manière de lire du code :D

Citation:

---

Envoyé par koala01

Mais bon, j'ai tendance à être verbeux dans ma manière de lire du code :D

---

Je confirme >< !

PS : Euh, tu as tojours pas mis le s pour transformer cont en const :aie: !

Citation:

---

Envoyé par Lavock

Je confirme >< !

PS : Euh, tu as tojours pas mis le s pour transformer cont en const :aie: !

---

S'il n'y a que ca pour te faire plaisir :D

Citation:

---

Envoyé par koala01

Le fait qu'ils soient écrit en majuscules me fait penser à des symboles définis par une directive préprocesseur...

---

ok, je comprends bien maintenant
Merci :ccool:

Citation:

---

Envoyé par mima_mine

ok, je comprends bien maintenant
Merci :ccool:

---

Attention, ce ne sont que supputations de ma part... je peux tout aussi bien partir dans une direction totalement opposée à la réalité de la chose :D

Salut,
Je n'ai pas mémoire d'avoir vu l'ajout d'attribut in/out pour C++0x. Le lien fourni décrit juste les souhaits de l'auteur sur ce qu'il aimerait voir dans le langage ... et ça n'engage que lui.
Sinon, comme l'a précisé Koala, const est encore le meilleur indicateur d'un paramètre in ou out, y compris pour 'this' avec les fonctions constantes.

Le in/out tel qu'on peut le voir en .Net (comme les mots-clés ref et out en C#) possède une distinction de plus que const&/non-const&: Les vérifications d'initialisation.

• Un paramètre in/out (ref) doit être initialisé avant l'appel de la fonction.
• Un paramètre out n'en a pas besoin, mais doit être écrit au moins une fois dans la fonction, pour chaque chemin possible où la fonction retourne.

Citation:

---

Envoyé par mima_mine

Bonjour tous le monde, je développe un parser C++, donc j'ai besoin de comprendre la syntaxe d'abord, et tous les cas possible pour ecrire cette syntaxe :roll:

---

Je suis en train de développer un tel projet.
Je t'invite à suivre le lien dans ma signature !