std::string RXMove::index2Coord(int index) {
if(index == PASS)
return "PA";
std::string coord = "";
coord += char((index%9 - 1) + 'A');
coord += char((index/9 - 1) + '1');
return coord;
}
avec des appels
std::string coord = RXMove::index2Coord(10);
cela fonctionne, mais...
1) est'il correcte de creer un objet (sur la pile) et de le retourner a
la fin de la fonction ?
(n'est il pas detruit?)
2) n'y a t'il pas multiple copies de nom objet? (au moins une ici
std::string coord = RXMove::index2Coord(10);)
3) return "PA"; est equivalent a return std:string temporaire > "PA"; ?
4) y a t'il une fuite de memoire? quand est detruit
RXMove::index2Coord(10) ?
std::string RXMove::index2Coord(int index) {
if(index == PASS)
return "PA";
std::string coord = "";
coord += char((index%9 - 1) + 'A');
coord += char((index/9 - 1) + '1');
return coord;
}
avec des appels
std::string coord = RXMove::index2Coord(10);
cela fonctionne, mais...
1) est'il correcte de creer un objet (sur la pile) et de le retourner a
la fin de la fonction ?
(n'est il pas detruit?)
2) n'y a t'il pas multiple copies de nom objet? (au moins une ici
std::string coord = RXMove::index2Coord(10);)
3) return "PA"; est equivalent a return std:string temporaire > "PA"; ?
4) y a t'il une fuite de memoire? quand est detruit
RXMove::index2Coord(10) ?
std::string RXMove::index2Coord(int index) {
if(index == PASS)
return "PA";
std::string coord = "";
coord += char((index%9 - 1) + 'A');
coord += char((index/9 - 1) + '1');
return coord;
}
avec des appels
std::string coord = RXMove::index2Coord(10);
cela fonctionne, mais...
1) est'il correcte de creer un objet (sur la pile) et de le retourner a
la fin de la fonction ?
(n'est il pas detruit?)
2) n'y a t'il pas multiple copies de nom objet? (au moins une ici
std::string coord = RXMove::index2Coord(10);)
3) return "PA"; est equivalent a return std:string temporaire > "PA"; ?
4) y a t'il une fuite de memoire? quand est detruit
RXMove::index2Coord(10) ?
j'ai une methode qui retourne un coordonnée (string) a partir
d'un index (int)
std::string RXMove::index2Coord(int index) {
if(index == PASS)
return "PA";
std::string coord = "";
coord += char((index%9 - 1) + 'A');
coord += char((index/9 - 1) + '1');
return coord;
}
avec des appels
std::string coord = RXMove::index2Coord(10);
cela fonctionne, mais...
1) est'il correcte de creer un objet (sur la pile) et de le
retourner a la fin de la fonction ? (n'est il pas detruit?)
2) n'y a t'il pas multiple copies de nom objet? (au moins une
ici std::string coord = RXMove::index2Coord(10);)
3) return "PA"; est equivalent a return std:string temporaire
= "PA"; ?
4) y a t'il une fuite de memoire? quand est detruit
RXMove::index2Coord(10) ?
et enfin comment faut t'il coder cette methode :-)
j'ai une methode qui retourne un coordonnée (string) a partir
d'un index (int)
std::string RXMove::index2Coord(int index) {
if(index == PASS)
return "PA";
std::string coord = "";
coord += char((index%9 - 1) + 'A');
coord += char((index/9 - 1) + '1');
return coord;
}
avec des appels
std::string coord = RXMove::index2Coord(10);
cela fonctionne, mais...
1) est'il correcte de creer un objet (sur la pile) et de le
retourner a la fin de la fonction ? (n'est il pas detruit?)
2) n'y a t'il pas multiple copies de nom objet? (au moins une
ici std::string coord = RXMove::index2Coord(10);)
3) return "PA"; est equivalent a return std:string temporaire
= "PA"; ?
4) y a t'il une fuite de memoire? quand est detruit
RXMove::index2Coord(10) ?
et enfin comment faut t'il coder cette methode :-)
j'ai une methode qui retourne un coordonnée (string) a partir
d'un index (int)
std::string RXMove::index2Coord(int index) {
if(index == PASS)
return "PA";
std::string coord = "";
coord += char((index%9 - 1) + 'A');
coord += char((index/9 - 1) + '1');
return coord;
}
avec des appels
std::string coord = RXMove::index2Coord(10);
cela fonctionne, mais...
1) est'il correcte de creer un objet (sur la pile) et de le
retourner a la fin de la fonction ? (n'est il pas detruit?)
2) n'y a t'il pas multiple copies de nom objet? (au moins une
ici std::string coord = RXMove::index2Coord(10);)
3) return "PA"; est equivalent a return std:string temporaire
= "PA"; ?
4) y a t'il une fuite de memoire? quand est detruit
RXMove::index2Coord(10) ?
et enfin comment faut t'il coder cette methode :-)
Tant que tu n'utilises pas de pointeurs, tu ne peux pas
vraiment avoir de fuite de mémoire en fait (mais tu peux
utiliser des classes qui utilisent des pointeurs par contre).
Tant que tu n'utilises pas de pointeurs, tu ne peux pas
vraiment avoir de fuite de mémoire en fait (mais tu peux
utiliser des classes qui utilisent des pointeurs par contre).
Tant que tu n'utilises pas de pointeurs, tu ne peux pas
vraiment avoir de fuite de mémoire en fait (mais tu peux
utiliser des classes qui utilisent des pointeurs par contre).
En passant : l'expression ci-dessus a un comportement indéfini,
même s'il marche sur tous les systèmes que j'ai jamais vu. (Les
caractères alpha ne sont pas contigus en EBCDIC, mais les 8
premiers le sont.) La solution « classique », c'est quelque
chose du genre :
coord += "ABCDEFGH"[ index % 9 - 1 ] ;
Je me pose également une question sur le -1. L'opérateur modulo
va donner un résultat entre 0 et 8 compris. -1 fait de -1 à 7.
Indexer avec -1 n'est pas défini non plus.
Si c'est réelement ce que tu veux, j'ajouterais au moins un
assert avant : « assert( index % 9 != 0 ) ». Et même alors, le
code serait plus robuste avec « "?ABCDEFGH"[ index % 9 ] », avec
un renvoie de '?' en cas d'erreur.coord += char((index/9 - 1) + '1');
Même commentaire pour le -1. Et j'ajouterais aussi un assert
ici, du genre « assert( index < 81 ) », juste pour être sûr.
Question de goût personnel, j'utiliserais aussi la technique
avec le tableau. La contiguïté des codes des chiffres est
garantie par la norme, mais je ne vois pas de raison de faire
différemment pour les chiffres que pour les autres caractères.
1) est'il correcte de creer un objet (sur la pile) et de le
retourner a la fin de la fonction ? (n'est il pas detruit?)
L'objet même est détruit, mais pas avant qu'on en a fait la
copie. C'est la façon « normale » de renvoyer des valeurs.2) n'y a t'il pas multiple copies de nom objet? (au moins une
ici std::string coord = RXMove::index2Coord(10);)
P't-êt' ben. Formellement, il y a des copies. Mais la norme
autorise explicitement le compilateur de les supprimer, même si
le constructeur de copie a des effets de bord visible.
Il faut dire aussi qu'on copie des chaînes beaucoup dans
certains programmes, au point où on peut s'attendre à ce que
l'implémentation y a fait un peu d'attention aux performances,
pour qu'une copie ne soit pas chère.
Dans l'ensemble, je ne m'en inquièterais pas, sauf si le code
est réelement trop lent, et que le profiler dit que c'est un
problème.
3) return "PA"; est equivalent a return std:string temporaire
= "PA"; ?
return std::string( "PA" ) ;
4) y a t'il une fuite de memoire? quand est detruit
RXMove::index2Coord(10) ?
Quand on a fini avec lui. En fait, à la fin de l'expression
complète où la fonction a été appelée, dans la plupart des cas ;
à la fin de l'initialisation, si l'expression sert à
l'initialisation d'une variable, et si l'expression sert
directement à l'initialisation d'une référence (forcément
const), à la fin de la portée de la référence.
et enfin comment faut t'il coder cette methode :-)
Voir ci-dessus. Sinon :
std::string RXMove::index2Coord(int index)
{
std::ostringstream tmp ;
if ( index == PASS ) {
tmp << "PA" ;
} else {
tmp << "ABCDEFGH"[ index % 9 ]
<< std::dec << index / 9 ;
}
return tmp.str() ;
}
J'avoue que dans ce cas-ci, l'utilisation de stringstream me
semble un peu lourd, mais c'est un bon outil général.
Si on aime le style fonctionnel, on pourrait aussi écrire :
std::string
RXMove::index2Coord(
int index )
{
assert( index == PASS
|| (index >= 9 && index < 81 && index % 9 != 0) ) ;
return index == PASS
? std::string( "PA" )
: ( std::string( 1, "?ABCDEFGH"[ index % 9 ] )
+ std::string( 1, "?12345678"[ index / 9 ] ) ;
}
C'est en fait la forme qui me plaît le plus (et c'est comme ça
que je l'écrirais dans la pratique).
En passant : l'expression ci-dessus a un comportement indéfini,
même s'il marche sur tous les systèmes que j'ai jamais vu. (Les
caractères alpha ne sont pas contigus en EBCDIC, mais les 8
premiers le sont.) La solution « classique », c'est quelque
chose du genre :
coord += "ABCDEFGH"[ index % 9 - 1 ] ;
Je me pose également une question sur le -1. L'opérateur modulo
va donner un résultat entre 0 et 8 compris. -1 fait de -1 à 7.
Indexer avec -1 n'est pas défini non plus.
Si c'est réelement ce que tu veux, j'ajouterais au moins un
assert avant : « assert( index % 9 != 0 ) ». Et même alors, le
code serait plus robuste avec « "?ABCDEFGH"[ index % 9 ] », avec
un renvoie de '?' en cas d'erreur.
coord += char((index/9 - 1) + '1');
Même commentaire pour le -1. Et j'ajouterais aussi un assert
ici, du genre « assert( index < 81 ) », juste pour être sûr.
Question de goût personnel, j'utiliserais aussi la technique
avec le tableau. La contiguïté des codes des chiffres est
garantie par la norme, mais je ne vois pas de raison de faire
différemment pour les chiffres que pour les autres caractères.
1) est'il correcte de creer un objet (sur la pile) et de le
retourner a la fin de la fonction ? (n'est il pas detruit?)
L'objet même est détruit, mais pas avant qu'on en a fait la
copie. C'est la façon « normale » de renvoyer des valeurs.
2) n'y a t'il pas multiple copies de nom objet? (au moins une
ici std::string coord = RXMove::index2Coord(10);)
P't-êt' ben. Formellement, il y a des copies. Mais la norme
autorise explicitement le compilateur de les supprimer, même si
le constructeur de copie a des effets de bord visible.
Il faut dire aussi qu'on copie des chaînes beaucoup dans
certains programmes, au point où on peut s'attendre à ce que
l'implémentation y a fait un peu d'attention aux performances,
pour qu'une copie ne soit pas chère.
Dans l'ensemble, je ne m'en inquièterais pas, sauf si le code
est réelement trop lent, et que le profiler dit que c'est un
problème.
3) return "PA"; est equivalent a return std:string temporaire
= "PA"; ?
return std::string( "PA" ) ;
4) y a t'il une fuite de memoire? quand est detruit
RXMove::index2Coord(10) ?
Quand on a fini avec lui. En fait, à la fin de l'expression
complète où la fonction a été appelée, dans la plupart des cas ;
à la fin de l'initialisation, si l'expression sert à
l'initialisation d'une variable, et si l'expression sert
directement à l'initialisation d'une référence (forcément
const), à la fin de la portée de la référence.
et enfin comment faut t'il coder cette methode :-)
Voir ci-dessus. Sinon :
std::string RXMove::index2Coord(int index)
{
std::ostringstream tmp ;
if ( index == PASS ) {
tmp << "PA" ;
} else {
tmp << "ABCDEFGH"[ index % 9 ]
<< std::dec << index / 9 ;
}
return tmp.str() ;
}
J'avoue que dans ce cas-ci, l'utilisation de stringstream me
semble un peu lourd, mais c'est un bon outil général.
Si on aime le style fonctionnel, on pourrait aussi écrire :
std::string
RXMove::index2Coord(
int index )
{
assert( index == PASS
|| (index >= 9 && index < 81 && index % 9 != 0) ) ;
return index == PASS
? std::string( "PA" )
: ( std::string( 1, "?ABCDEFGH"[ index % 9 ] )
+ std::string( 1, "?12345678"[ index / 9 ] ) ;
}
C'est en fait la forme qui me plaît le plus (et c'est comme ça
que je l'écrirais dans la pratique).
En passant : l'expression ci-dessus a un comportement indéfini,
même s'il marche sur tous les systèmes que j'ai jamais vu. (Les
caractères alpha ne sont pas contigus en EBCDIC, mais les 8
premiers le sont.) La solution « classique », c'est quelque
chose du genre :
coord += "ABCDEFGH"[ index % 9 - 1 ] ;
Je me pose également une question sur le -1. L'opérateur modulo
va donner un résultat entre 0 et 8 compris. -1 fait de -1 à 7.
Indexer avec -1 n'est pas défini non plus.
Si c'est réelement ce que tu veux, j'ajouterais au moins un
assert avant : « assert( index % 9 != 0 ) ». Et même alors, le
code serait plus robuste avec « "?ABCDEFGH"[ index % 9 ] », avec
un renvoie de '?' en cas d'erreur.coord += char((index/9 - 1) + '1');
Même commentaire pour le -1. Et j'ajouterais aussi un assert
ici, du genre « assert( index < 81 ) », juste pour être sûr.
Question de goût personnel, j'utiliserais aussi la technique
avec le tableau. La contiguïté des codes des chiffres est
garantie par la norme, mais je ne vois pas de raison de faire
différemment pour les chiffres que pour les autres caractères.
1) est'il correcte de creer un objet (sur la pile) et de le
retourner a la fin de la fonction ? (n'est il pas detruit?)
L'objet même est détruit, mais pas avant qu'on en a fait la
copie. C'est la façon « normale » de renvoyer des valeurs.2) n'y a t'il pas multiple copies de nom objet? (au moins une
ici std::string coord = RXMove::index2Coord(10);)
P't-êt' ben. Formellement, il y a des copies. Mais la norme
autorise explicitement le compilateur de les supprimer, même si
le constructeur de copie a des effets de bord visible.
Il faut dire aussi qu'on copie des chaînes beaucoup dans
certains programmes, au point où on peut s'attendre à ce que
l'implémentation y a fait un peu d'attention aux performances,
pour qu'une copie ne soit pas chère.
Dans l'ensemble, je ne m'en inquièterais pas, sauf si le code
est réelement trop lent, et que le profiler dit que c'est un
problème.
3) return "PA"; est equivalent a return std:string temporaire
= "PA"; ?
return std::string( "PA" ) ;
4) y a t'il une fuite de memoire? quand est detruit
RXMove::index2Coord(10) ?
Quand on a fini avec lui. En fait, à la fin de l'expression
complète où la fonction a été appelée, dans la plupart des cas ;
à la fin de l'initialisation, si l'expression sert à
l'initialisation d'une variable, et si l'expression sert
directement à l'initialisation d'une référence (forcément
const), à la fin de la portée de la référence.
et enfin comment faut t'il coder cette methode :-)
Voir ci-dessus. Sinon :
std::string RXMove::index2Coord(int index)
{
std::ostringstream tmp ;
if ( index == PASS ) {
tmp << "PA" ;
} else {
tmp << "ABCDEFGH"[ index % 9 ]
<< std::dec << index / 9 ;
}
return tmp.str() ;
}
J'avoue que dans ce cas-ci, l'utilisation de stringstream me
semble un peu lourd, mais c'est un bon outil général.
Si on aime le style fonctionnel, on pourrait aussi écrire :
std::string
RXMove::index2Coord(
int index )
{
assert( index == PASS
|| (index >= 9 && index < 81 && index % 9 != 0) ) ;
return index == PASS
? std::string( "PA" )
: ( std::string( 1, "?ABCDEFGH"[ index % 9 ] )
+ std::string( 1, "?12345678"[ index / 9 ] ) ;
}
C'est en fait la forme qui me plaît le plus (et c'est comme ça
que je l'écrirais dans la pratique).
Existe t'il sur le net une documentation genre API java
Pour les classes standards (normalisées) de C++;
Existe t'il sur le net une documentation genre API java
Pour les classes standards (normalisées) de C++;
Existe t'il sur le net une documentation genre API java
Pour les classes standards (normalisées) de C++;
dans l'article
,
à a écrit le 13/05/05
9:17 :
static protected String index2Coord(int square) {
if (square == PASS)
return "PS";
int temp = square%9;
StringBuffer coord = new StringBuffer();
coord.append(" ABCDEFGH".charAt(temp));
coord.append((square-temp)/9);
return coord.toString();
}
C'est comme ça que je l'ai codé en java :-)
dans l'article
1115968643.210965.61250@g44g2000cwa.googlegroups.com,
kanze@gabi-soft.fr à kanze@gabi-soft.fr a écrit le 13/05/05
9:17 :
static protected String index2Coord(int square) {
if (square == PASS)
return "PS";
int temp = square%9;
StringBuffer coord = new StringBuffer();
coord.append(" ABCDEFGH".charAt(temp));
coord.append((square-temp)/9);
return coord.toString();
}
C'est comme ça que je l'ai codé en java :-)
dans l'article
,
à a écrit le 13/05/05
9:17 :
static protected String index2Coord(int square) {
if (square == PASS)
return "PS";
int temp = square%9;
StringBuffer coord = new StringBuffer();
coord.append(" ABCDEFGH".charAt(temp));
coord.append((square-temp)/9);
return coord.toString();
}
C'est comme ça que je l'ai codé en java :-)