bonjour à tous,
je me pose une question concernant le double référencement d'une
variable en C:
peut-on considérer que un pointeur d'un pointeur (en C) est équivalent
(au moins dans l'esprit) à la notion de référence en C++
int **foo(C) =?= int & foo(C++)
bonjour à tous,
je me pose une question concernant le double référencement d'une
variable en C:
peut-on considérer que un pointeur d'un pointeur (en C) est équivalent
(au moins dans l'esprit) à la notion de référence en C++
int **foo(C) =?= int & foo(C++)
bonjour à tous,
je me pose une question concernant le double référencement d'une
variable en C:
peut-on considérer que un pointeur d'un pointeur (en C) est équivalent
(au moins dans l'esprit) à la notion de référence en C++
int **foo(C) =?= int & foo(C++)
xylo writes:bonjour à tous,
je me pose une question concernant le double référencement d'une
variable en C:
peut-on considérer que un pointeur d'un pointeur (en C) est équivalent
(au moins dans l'esprit) à la notion de référence en C++
int **foo(C) =?= int & foo(C++)
Non. Tu peux en premiere approximation considerer une reference C++ comme
un pointeur dereference automatiquement.
xylo <public.jmm@free.fr> writes:
bonjour à tous,
je me pose une question concernant le double référencement d'une
variable en C:
peut-on considérer que un pointeur d'un pointeur (en C) est équivalent
(au moins dans l'esprit) à la notion de référence en C++
int **foo(C) =?= int & foo(C++)
Non. Tu peux en premiere approximation considerer une reference C++ comme
un pointeur dereference automatiquement.
xylo writes:bonjour à tous,
je me pose une question concernant le double référencement d'une
variable en C:
peut-on considérer que un pointeur d'un pointeur (en C) est équivalent
(au moins dans l'esprit) à la notion de référence en C++
int **foo(C) =?= int & foo(C++)
Non. Tu peux en premiere approximation considerer une reference C++ comme
un pointeur dereference automatiquement.
Les références sont une fausse bonne idée.
Elles permettent d'alléger l'écriture au prix d'une plus grande
incertitude sur la semantique réelle du code : le lecteur du code C++
peut plus facilement se tromper sur la signification du code dont les
effets de bord sont moins visibles.
Mais elles n'ont pas l'élégance des n-uplets
Les références sont une fausse bonne idée.
Elles permettent d'alléger l'écriture au prix d'une plus grande
incertitude sur la semantique réelle du code : le lecteur du code C++
peut plus facilement se tromper sur la signification du code dont les
effets de bord sont moins visibles.
Mais elles n'ont pas l'élégance des n-uplets
Les références sont une fausse bonne idée.
Elles permettent d'alléger l'écriture au prix d'une plus grande
incertitude sur la semantique réelle du code : le lecteur du code C++
peut plus facilement se tromper sur la signification du code dont les
effets de bord sont moins visibles.
Mais elles n'ont pas l'élégance des n-uplets
"Charlie Gordon" writes:Les références sont une fausse bonne idée.
Pas d'accord. C'est quelque chose dont on peut abuser -- mais on
considere
que la possibilite d'un abus doit condamner une feature, on n'est pas dans
le bon groupe.
Elles permettent d'alléger l'écriture au prix d'une plus grande
incertitude sur la semantique réelle du code : le lecteur du code C++
peut plus facilement se tromper sur la signification du code dont les
effets de bord sont moins visibles.
Ca ne m'a jamais pose un probleme. En C++ ou dans les autres langages qui
ont le meme non-probleme de ne pas marquer a l'appel les parametres out ou
in out. (Au contraire, je trouve problematique de prendre l'adresse d'une
variable locale et les references me permettent un style ou ce n'est
jamais
necessaire -- en fait c'est un de mes criteres pour choisir entre une
reference ou un pointeur).
Mais elles n'ont pas l'élégance des n-uplets
J'ai du mal a voir le rapport entre les n-uplets et les references. (En
passant, rien n'empeche d'avoir une ABI permettant le passage et le retour
de petites structures par les registres -- ca m'etonnerait qu'il n'y en
ait
pas d'ailleurs).
"Charlie Gordon" <news@chqrlie.org> writes:
Les références sont une fausse bonne idée.
Pas d'accord. C'est quelque chose dont on peut abuser -- mais on
considere
que la possibilite d'un abus doit condamner une feature, on n'est pas dans
le bon groupe.
Elles permettent d'alléger l'écriture au prix d'une plus grande
incertitude sur la semantique réelle du code : le lecteur du code C++
peut plus facilement se tromper sur la signification du code dont les
effets de bord sont moins visibles.
Ca ne m'a jamais pose un probleme. En C++ ou dans les autres langages qui
ont le meme non-probleme de ne pas marquer a l'appel les parametres out ou
in out. (Au contraire, je trouve problematique de prendre l'adresse d'une
variable locale et les references me permettent un style ou ce n'est
jamais
necessaire -- en fait c'est un de mes criteres pour choisir entre une
reference ou un pointeur).
Mais elles n'ont pas l'élégance des n-uplets
J'ai du mal a voir le rapport entre les n-uplets et les references. (En
passant, rien n'empeche d'avoir une ABI permettant le passage et le retour
de petites structures par les registres -- ca m'etonnerait qu'il n'y en
ait
pas d'ailleurs).
"Charlie Gordon" writes:Les références sont une fausse bonne idée.
Pas d'accord. C'est quelque chose dont on peut abuser -- mais on
considere
que la possibilite d'un abus doit condamner une feature, on n'est pas dans
le bon groupe.
Elles permettent d'alléger l'écriture au prix d'une plus grande
incertitude sur la semantique réelle du code : le lecteur du code C++
peut plus facilement se tromper sur la signification du code dont les
effets de bord sont moins visibles.
Ca ne m'a jamais pose un probleme. En C++ ou dans les autres langages qui
ont le meme non-probleme de ne pas marquer a l'appel les parametres out ou
in out. (Au contraire, je trouve problematique de prendre l'adresse d'une
variable locale et les references me permettent un style ou ce n'est
jamais
necessaire -- en fait c'est un de mes criteres pour choisir entre une
reference ou un pointeur).
Mais elles n'ont pas l'élégance des n-uplets
J'ai du mal a voir le rapport entre les n-uplets et les references. (En
passant, rien n'empeche d'avoir une ABI permettant le passage et le retour
de petites structures par les registres -- ca m'etonnerait qu'il n'y en
ait
pas d'ailleurs).
[Les références] n'ont pas l'élégance des n-uplets : la possibilité
pour une fonction de retourner efficacement plusieurs valeurs, comme
pointeur+longueur, pointeur+indication de succès... Cette construction
n'existe ni en C, ni en C++. L'alternative consistant à retouner une
structure est lourdingue, aussi bien pour la syntaxe que pour
l'implementation,
alors que le nombre de registres des processeurs
augmentant, une ABI efficace est possible pour retourner plusieurs
valeurs dont certaines seront ignorées.
[Les références] n'ont pas l'élégance des n-uplets : la possibilité
pour une fonction de retourner efficacement plusieurs valeurs, comme
pointeur+longueur, pointeur+indication de succès... Cette construction
n'existe ni en C, ni en C++. L'alternative consistant à retouner une
structure est lourdingue, aussi bien pour la syntaxe que pour
l'implementation,
alors que le nombre de registres des processeurs
augmentant, une ABI efficace est possible pour retourner plusieurs
valeurs dont certaines seront ignorées.
[Les références] n'ont pas l'élégance des n-uplets : la possibilité
pour une fonction de retourner efficacement plusieurs valeurs, comme
pointeur+longueur, pointeur+indication de succès... Cette construction
n'existe ni en C, ni en C++. L'alternative consistant à retouner une
structure est lourdingue, aussi bien pour la syntaxe que pour
l'implementation,
alors que le nombre de registres des processeurs
augmentant, une ABI efficace est possible pour retourner plusieurs
valeurs dont certaines seront ignorées.
"Jean-Marc Bourguet" a écrit dans le message de new s:
> "Charlie Gordon" writes:
>> Les références sont une fausse bonne idée.
> Pas d'accord. C'est quelque chose dont on peut abuser -- mais on
> considere
> que la possibilite d'un abus doit condamner une feature, on n'est pas d ans
> le bon groupe.
Baliser les écueils est toujours une bonne chose.
Interdire les plus dangereux est souhaitable : gets, strncpy...
>> Elles permettent d'alléger l'écriture au prix d'une plus grande
>> incertitude sur la semantique réelle du code : le lecteur du code C+ +
>> peut plus facilement se tromper sur la signification du code dont les
>> effets de bord sont moins visibles.
> Ca ne m'a jamais pose un probleme. En C++ ou dans les autres langages qui
> ont le meme non-probleme de ne pas marquer a l'appel les parametres out ou
> in out. (Au contraire, je trouve problematique de prendre l'adresse d' une
> variable locale et les references me permettent un style ou ce n'est
> jamais
> necessaire -- en fait c'est un de mes criteres pour choisir entre une
> reference ou un pointeur).
Plutôt que "fausse bonne idée", j'aurais dû écrire "pas la panac ée". Outre
la possibilité de retourner des lvalues, cette notation est utilisée pour
permettre de modifier des variables 'in/out', qui sont souvent une mauvai se
idée, ou des variables 'out' qui ne peuvent effectivement pas être d éclarées
commes telles dans le prototype de la fonction. L'utilisation de réf érences
présente certains avantages comme l'allègement de la syntaxe, la non nullité
implicite, mais rendent le code potentiellement plus facile à mal
interpréter. Je ne dis pas qu'elles n'ont pas leur utilité, juste qu 'elle
ne sont pas une solution idéale.
>> Mais elles n'ont pas l'élégance des n-uplets
> J'ai du mal a voir le rapport entre les n-uplets et les references. (E n
> passant, rien n'empeche d'avoir une ABI permettant le passage et le ret our
> de petites structures par les registres -- ca m'etonnerait qu'il n'y en
> ait
> pas d'ailleurs).
Les n-uplets sont une methode pour retourner plusieurs valeurs qui a
l'avantage d'utiliser une notation fonctionnelle et d'éviter l'ambiguit é des
paramètres passés par reference ou par pointeur dont on ne sait pas d ire
qu'ils sont "out" ou "in/out".
pointeurs, soit retourner des structures, en C++ on peut utiliser des
references plutôt que des pointeurs. Les ABI courantes permettent
effectivement souvent de passer les petites structures en parametres et e n
valeur de retour dans des registres, mais la syntaxe reste lourde : il fa ut
stocker le resultat dans une structure pour en utiliser les champs dans u ne
instruction separee. Avec des n-uplets, on peut plus facilement ignorer
certaines valeurs de retour et ne stocker que celles qui sont utiles ou l es
reutiliser directement dans l'expression englobant l'appel de fonction. Les
references seront peut-etre incluses dans la prochaine revision du Standa rd
C1x, en revanche les n-uplets ont peu de chances d'y parvenir, donc cette
discussion est un peu vaine.
--
Chqrlie.
"Jean-Marc Bourguet" <j...@bourguet.org> a écrit dans le message de new s:
pxbprljimep....@news.bourguet.org...
> "Charlie Gordon" <n...@chqrlie.org> writes:
>> Les références sont une fausse bonne idée.
> Pas d'accord. C'est quelque chose dont on peut abuser -- mais on
> considere
> que la possibilite d'un abus doit condamner une feature, on n'est pas d ans
> le bon groupe.
Baliser les écueils est toujours une bonne chose.
Interdire les plus dangereux est souhaitable : gets, strncpy...
>> Elles permettent d'alléger l'écriture au prix d'une plus grande
>> incertitude sur la semantique réelle du code : le lecteur du code C+ +
>> peut plus facilement se tromper sur la signification du code dont les
>> effets de bord sont moins visibles.
> Ca ne m'a jamais pose un probleme. En C++ ou dans les autres langages qui
> ont le meme non-probleme de ne pas marquer a l'appel les parametres out ou
> in out. (Au contraire, je trouve problematique de prendre l'adresse d' une
> variable locale et les references me permettent un style ou ce n'est
> jamais
> necessaire -- en fait c'est un de mes criteres pour choisir entre une
> reference ou un pointeur).
Plutôt que "fausse bonne idée", j'aurais dû écrire "pas la panac ée". Outre
la possibilité de retourner des lvalues, cette notation est utilisée pour
permettre de modifier des variables 'in/out', qui sont souvent une mauvai se
idée, ou des variables 'out' qui ne peuvent effectivement pas être d éclarées
commes telles dans le prototype de la fonction. L'utilisation de réf érences
présente certains avantages comme l'allègement de la syntaxe, la non nullité
implicite, mais rendent le code potentiellement plus facile à mal
interpréter. Je ne dis pas qu'elles n'ont pas leur utilité, juste qu 'elle
ne sont pas une solution idéale.
>> Mais elles n'ont pas l'élégance des n-uplets
> J'ai du mal a voir le rapport entre les n-uplets et les references. (E n
> passant, rien n'empeche d'avoir une ABI permettant le passage et le ret our
> de petites structures par les registres -- ca m'etonnerait qu'il n'y en
> ait
> pas d'ailleurs).
Les n-uplets sont une methode pour retourner plusieurs valeurs qui a
l'avantage d'utiliser une notation fonctionnelle et d'éviter l'ambiguit é des
paramètres passés par reference ou par pointeur dont on ne sait pas d ire
qu'ils sont "out" ou "in/out".
pointeurs, soit retourner des structures, en C++ on peut utiliser des
references plutôt que des pointeurs. Les ABI courantes permettent
effectivement souvent de passer les petites structures en parametres et e n
valeur de retour dans des registres, mais la syntaxe reste lourde : il fa ut
stocker le resultat dans une structure pour en utiliser les champs dans u ne
instruction separee. Avec des n-uplets, on peut plus facilement ignorer
certaines valeurs de retour et ne stocker que celles qui sont utiles ou l es
reutiliser directement dans l'expression englobant l'appel de fonction. Les
references seront peut-etre incluses dans la prochaine revision du Standa rd
C1x, en revanche les n-uplets ont peu de chances d'y parvenir, donc cette
discussion est un peu vaine.
--
Chqrlie.
"Jean-Marc Bourguet" a écrit dans le message de new s:
> "Charlie Gordon" writes:
>> Les références sont une fausse bonne idée.
> Pas d'accord. C'est quelque chose dont on peut abuser -- mais on
> considere
> que la possibilite d'un abus doit condamner une feature, on n'est pas d ans
> le bon groupe.
Baliser les écueils est toujours une bonne chose.
Interdire les plus dangereux est souhaitable : gets, strncpy...
>> Elles permettent d'alléger l'écriture au prix d'une plus grande
>> incertitude sur la semantique réelle du code : le lecteur du code C+ +
>> peut plus facilement se tromper sur la signification du code dont les
>> effets de bord sont moins visibles.
> Ca ne m'a jamais pose un probleme. En C++ ou dans les autres langages qui
> ont le meme non-probleme de ne pas marquer a l'appel les parametres out ou
> in out. (Au contraire, je trouve problematique de prendre l'adresse d' une
> variable locale et les references me permettent un style ou ce n'est
> jamais
> necessaire -- en fait c'est un de mes criteres pour choisir entre une
> reference ou un pointeur).
Plutôt que "fausse bonne idée", j'aurais dû écrire "pas la panac ée". Outre
la possibilité de retourner des lvalues, cette notation est utilisée pour
permettre de modifier des variables 'in/out', qui sont souvent une mauvai se
idée, ou des variables 'out' qui ne peuvent effectivement pas être d éclarées
commes telles dans le prototype de la fonction. L'utilisation de réf érences
présente certains avantages comme l'allègement de la syntaxe, la non nullité
implicite, mais rendent le code potentiellement plus facile à mal
interpréter. Je ne dis pas qu'elles n'ont pas leur utilité, juste qu 'elle
ne sont pas une solution idéale.
>> Mais elles n'ont pas l'élégance des n-uplets
> J'ai du mal a voir le rapport entre les n-uplets et les references. (E n
> passant, rien n'empeche d'avoir une ABI permettant le passage et le ret our
> de petites structures par les registres -- ca m'etonnerait qu'il n'y en
> ait
> pas d'ailleurs).
Les n-uplets sont une methode pour retourner plusieurs valeurs qui a
l'avantage d'utiliser une notation fonctionnelle et d'éviter l'ambiguit é des
paramètres passés par reference ou par pointeur dont on ne sait pas d ire
qu'ils sont "out" ou "in/out".
pointeurs, soit retourner des structures, en C++ on peut utiliser des
references plutôt que des pointeurs. Les ABI courantes permettent
effectivement souvent de passer les petites structures en parametres et e n
valeur de retour dans des registres, mais la syntaxe reste lourde : il fa ut
stocker le resultat dans une structure pour en utiliser les champs dans u ne
instruction separee. Avec des n-uplets, on peut plus facilement ignorer
certaines valeurs de retour et ne stocker que celles qui sont utiles ou l es
reutiliser directement dans l'expression englobant l'appel de fonction. Les
references seront peut-etre incluses dans la prochaine revision du Standa rd
C1x, en revanche les n-uplets ont peu de chances d'y parvenir, donc cette
discussion est un peu vaine.
--
Chqrlie.
const char * => ne peut pas être in est C tout.
const char * => ne peut pas être in est C tout.
const char * => ne peut pas être in est C tout.
"xylo" a écrit dans le message de news:const char * => ne peut pas être in est C tout.
En l'occurrence, const char * ne peut être QUE "in".
"xylo" <public.jmm@free.fr> a écrit dans le message de news:
2d94b0f2-d68a-4139-ba1f-8ca5ebc00970@r66g2000hsg.googlegroups.com...
const char * => ne peut pas être in est C tout.
En l'occurrence, const char * ne peut être QUE "in".
"xylo" a écrit dans le message de news:const char * => ne peut pas être in est C tout.
En l'occurrence, const char * ne peut être QUE "in".
"Jean-Marc Bourguet" a écrit dans le message de news:"Charlie Gordon" writes:Les références sont une fausse bonne idée.
Pas d'accord. C'est quelque chose dont on peut abuser -- mais on
considere
que la possibilite d'un abus doit condamner une feature, on n'est pas dans
le bon groupe.
Baliser les écueils est toujours une bonne chose.
Interdire les plus dangereux est souhaitable : gets, strncpy...
Elles permettent d'alléger l'écriture au prix d'une plus grande
incertitude sur la semantique réelle du code : le lecteur du code C++
peut plus facilement se tromper sur la signification du code dont les
effets de bord sont moins visibles.
Ca ne m'a jamais pose un probleme. En C++ ou dans les autres langages qui
ont le meme non-probleme de ne pas marquer a l'appel les parametres out ou
in out. (Au contraire, je trouve problematique de prendre l'adresse d'une
variable locale et les references me permettent un style ou ce n'est
jamais
necessaire -- en fait c'est un de mes criteres pour choisir entre une
reference ou un pointeur).
Plutôt que "fausse bonne idée", j'aurais dû écrire "pas la panacée". Outre
la possibilité de retourner des lvalues, cette notation est utilisée pour
permettre de modifier des variables 'in/out', qui sont souvent une mauvaise
idée, ou des variables 'out' qui ne peuvent effectivement pas être déclarées
commes telles dans le prototype de la fonction. L'utilisation de références
présente certains avantages comme l'allègement de la syntaxe, la non nullité
implicite, mais rendent le code potentiellement plus facile à mal
interpréter. Je ne dis pas qu'elles n'ont pas leur utilité, juste qu'elle
ne sont pas une solution idéale.Mais elles n'ont pas l'élégance des n-uplets
J'ai du mal a voir le rapport entre les n-uplets et les references. (En
passant, rien n'empeche d'avoir une ABI permettant le passage et le retour
de petites structures par les registres -- ca m'etonnerait qu'il n'y en
ait
pas d'ailleurs).
Les n-uplets sont une methode pour retourner plusieurs valeurs qui a
l'avantage d'utiliser une notation fonctionnelle et d'éviter l'ambiguité des
paramètres passés par reference ou par pointeur dont on ne sait pas dire
qu'ils sont "out" ou "in/out".
"Jean-Marc Bourguet" <jm@bourguet.org> a écrit dans le message de news:
pxbprljimep.fsf@news.bourguet.org...
"Charlie Gordon" <news@chqrlie.org> writes:
Les références sont une fausse bonne idée.
Pas d'accord. C'est quelque chose dont on peut abuser -- mais on
considere
que la possibilite d'un abus doit condamner une feature, on n'est pas dans
le bon groupe.
Baliser les écueils est toujours une bonne chose.
Interdire les plus dangereux est souhaitable : gets, strncpy...
Elles permettent d'alléger l'écriture au prix d'une plus grande
incertitude sur la semantique réelle du code : le lecteur du code C++
peut plus facilement se tromper sur la signification du code dont les
effets de bord sont moins visibles.
Ca ne m'a jamais pose un probleme. En C++ ou dans les autres langages qui
ont le meme non-probleme de ne pas marquer a l'appel les parametres out ou
in out. (Au contraire, je trouve problematique de prendre l'adresse d'une
variable locale et les references me permettent un style ou ce n'est
jamais
necessaire -- en fait c'est un de mes criteres pour choisir entre une
reference ou un pointeur).
Plutôt que "fausse bonne idée", j'aurais dû écrire "pas la panacée". Outre
la possibilité de retourner des lvalues, cette notation est utilisée pour
permettre de modifier des variables 'in/out', qui sont souvent une mauvaise
idée, ou des variables 'out' qui ne peuvent effectivement pas être déclarées
commes telles dans le prototype de la fonction. L'utilisation de références
présente certains avantages comme l'allègement de la syntaxe, la non nullité
implicite, mais rendent le code potentiellement plus facile à mal
interpréter. Je ne dis pas qu'elles n'ont pas leur utilité, juste qu'elle
ne sont pas une solution idéale.
Mais elles n'ont pas l'élégance des n-uplets
J'ai du mal a voir le rapport entre les n-uplets et les references. (En
passant, rien n'empeche d'avoir une ABI permettant le passage et le retour
de petites structures par les registres -- ca m'etonnerait qu'il n'y en
ait
pas d'ailleurs).
Les n-uplets sont une methode pour retourner plusieurs valeurs qui a
l'avantage d'utiliser une notation fonctionnelle et d'éviter l'ambiguité des
paramètres passés par reference ou par pointeur dont on ne sait pas dire
qu'ils sont "out" ou "in/out".
"Jean-Marc Bourguet" a écrit dans le message de news:"Charlie Gordon" writes:Les références sont une fausse bonne idée.
Pas d'accord. C'est quelque chose dont on peut abuser -- mais on
considere
que la possibilite d'un abus doit condamner une feature, on n'est pas dans
le bon groupe.
Baliser les écueils est toujours une bonne chose.
Interdire les plus dangereux est souhaitable : gets, strncpy...
Elles permettent d'alléger l'écriture au prix d'une plus grande
incertitude sur la semantique réelle du code : le lecteur du code C++
peut plus facilement se tromper sur la signification du code dont les
effets de bord sont moins visibles.
Ca ne m'a jamais pose un probleme. En C++ ou dans les autres langages qui
ont le meme non-probleme de ne pas marquer a l'appel les parametres out ou
in out. (Au contraire, je trouve problematique de prendre l'adresse d'une
variable locale et les references me permettent un style ou ce n'est
jamais
necessaire -- en fait c'est un de mes criteres pour choisir entre une
reference ou un pointeur).
Plutôt que "fausse bonne idée", j'aurais dû écrire "pas la panacée". Outre
la possibilité de retourner des lvalues, cette notation est utilisée pour
permettre de modifier des variables 'in/out', qui sont souvent une mauvaise
idée, ou des variables 'out' qui ne peuvent effectivement pas être déclarées
commes telles dans le prototype de la fonction. L'utilisation de références
présente certains avantages comme l'allègement de la syntaxe, la non nullité
implicite, mais rendent le code potentiellement plus facile à mal
interpréter. Je ne dis pas qu'elles n'ont pas leur utilité, juste qu'elle
ne sont pas une solution idéale.Mais elles n'ont pas l'élégance des n-uplets
J'ai du mal a voir le rapport entre les n-uplets et les references. (En
passant, rien n'empeche d'avoir une ABI permettant le passage et le retour
de petites structures par les registres -- ca m'etonnerait qu'il n'y en
ait
pas d'ailleurs).
Les n-uplets sont une methode pour retourner plusieurs valeurs qui a
l'avantage d'utiliser une notation fonctionnelle et d'éviter l'ambiguité des
paramètres passés par reference ou par pointeur dont on ne sait pas dire
qu'ils sont "out" ou "in/out".
Les n-uplets sont une methode pour retourner plusieurs valeurs qui a
l'avantage d'utiliser une notation fonctionnelle et d'éviter l'ambiguité des
paramètres passés par reference ou par pointeur dont on ne sait pas dire
qu'ils sont "out" ou "in/out".
const char * => ne peut pas être in est C tout.
Les n-uplets sont une methode pour retourner plusieurs valeurs qui a
l'avantage d'utiliser une notation fonctionnelle et d'éviter l'ambiguité des
paramètres passés par reference ou par pointeur dont on ne sait pas dire
qu'ils sont "out" ou "in/out".
const char * => ne peut pas être in est C tout.
Les n-uplets sont une methode pour retourner plusieurs valeurs qui a
l'avantage d'utiliser une notation fonctionnelle et d'éviter l'ambiguité des
paramètres passés par reference ou par pointeur dont on ne sait pas dire
qu'ils sont "out" ou "in/out".
const char * => ne peut pas être in est C tout.