Hello,
Plutot que de relire pour la dixième fois le 30 chapitres et
tutoriaux sur les cast, auxquels je n'ai toujours rien panné, j'ai
décidé de changer de technique : je pose la question sur un cas
concret et j'affinerai ma connaissance au fur et à mesure. Dans
l'extrait de code :
Volumetric* create(Kind k){
Volumetric* v;
switch (k) {
case RAW:
v =new RawVolumetric;break;
default:
v =NULL;break;
}
return v;
}
il y a un v=NULL qui ne me semble pas très joli.
Il faudrait tout du moins que je le caste en Volumetric*, non ?
Et si oui, quel operateur dois-je utiliser ?
Hello,
Plutot que de relire pour la dixième fois le 30 chapitres et
tutoriaux sur les cast, auxquels je n'ai toujours rien panné, j'ai
décidé de changer de technique : je pose la question sur un cas
concret et j'affinerai ma connaissance au fur et à mesure. Dans
l'extrait de code :
Volumetric* create(Kind k){
Volumetric* v;
switch (k) {
case RAW:
v =new RawVolumetric;break;
default:
v =NULL;break;
}
return v;
}
il y a un v=NULL qui ne me semble pas très joli.
Il faudrait tout du moins que je le caste en Volumetric*, non ?
Et si oui, quel operateur dois-je utiliser ?
Hello,
Plutot que de relire pour la dixième fois le 30 chapitres et
tutoriaux sur les cast, auxquels je n'ai toujours rien panné, j'ai
décidé de changer de technique : je pose la question sur un cas
concret et j'affinerai ma connaissance au fur et à mesure. Dans
l'extrait de code :
Volumetric* create(Kind k){
Volumetric* v;
switch (k) {
case RAW:
v =new RawVolumetric;break;
default:
v =NULL;break;
}
return v;
}
il y a un v=NULL qui ne me semble pas très joli.
Il faudrait tout du moins que je le caste en Volumetric*, non ?
Et si oui, quel operateur dois-je utiliser ?
Tu peux remplacer par v=0, c'est equivalent.
Il faudrait tout du moins que je le caste en Volumetric*, non ?
non.
Tu peux remplacer par v=0, c'est equivalent.
Il faudrait tout du moins que je le caste en Volumetric*, non ?
non.
Tu peux remplacer par v=0, c'est equivalent.
Il faudrait tout du moins que je le caste en Volumetric*, non ?
non.
Tu peux remplacer par v=0, c'est equivalent.
Euh... C'est pas dangereux ? Je veux dire, jusqu'à présent, tous les
NULL que j'ai vu valaient effectivement 0, mais bon, j'imagines que si
on a inventé NULL c'est justement pour s'abstraire de la valeur, non ?Il faudrait tout du moins que je le caste en Volumetric*, non ?
non.
O_o
Mon compilo dit la meme chose que toi, mais je ne comprends pas bien.
Pour moi, NULL est (void*) par défaut... Ou en tout cas, tout sauf
typé.
Tu peux remplacer par v=0, c'est equivalent.
Euh... C'est pas dangereux ? Je veux dire, jusqu'à présent, tous les
NULL que j'ai vu valaient effectivement 0, mais bon, j'imagines que si
on a inventé NULL c'est justement pour s'abstraire de la valeur, non ?
Il faudrait tout du moins que je le caste en Volumetric*, non ?
non.
O_o
Mon compilo dit la meme chose que toi, mais je ne comprends pas bien.
Pour moi, NULL est (void*) par défaut... Ou en tout cas, tout sauf
typé.
Tu peux remplacer par v=0, c'est equivalent.
Euh... C'est pas dangereux ? Je veux dire, jusqu'à présent, tous les
NULL que j'ai vu valaient effectivement 0, mais bon, j'imagines que si
on a inventé NULL c'est justement pour s'abstraire de la valeur, non ?Il faudrait tout du moins que je le caste en Volumetric*, non ?
non.
O_o
Mon compilo dit la meme chose que toi, mais je ne comprends pas bien.
Pour moi, NULL est (void*) par défaut... Ou en tout cas, tout sauf
typé.
Volumetric* create(Kind k){
Volumetric* v;
Volumetric* create(Kind k){
Volumetric* v;
Volumetric* create(Kind k){
Volumetric* v;
Il faudrait tout du moins que je le caste en Volumetric*, non ?
non.
O_o
Mon compilo dit la meme chose que toi, mais je ne comprends pas bien.
Pour moi, NULL est (void*) par défaut...
Il faudrait tout du moins que je le caste en Volumetric*, non ?
non.
O_o
Mon compilo dit la meme chose que toi, mais je ne comprends pas bien.
Pour moi, NULL est (void*) par défaut...
Il faudrait tout du moins que je le caste en Volumetric*, non ?
non.
O_o
Mon compilo dit la meme chose que toi, mais je ne comprends pas bien.
Pour moi, NULL est (void*) par défaut...
mais certains n'aiment pas les fonctions avec plusieurs "return" ;
j'avoue ne pas trop savoir pourquoi.
mais certains n'aiment pas les fonctions avec plusieurs "return" ;
j'avoue ne pas trop savoir pourquoi.
mais certains n'aiment pas les fonctions avec plusieurs "return" ;
j'avoue ne pas trop savoir pourquoi.
Plutot que de relire pour la dixième fois le 30 chapitres et
tutoriaux sur les cast, auxquels je n'ai toujours rien panné, j'ai
décidé de changer de technique : je pose la question sur un cas
concret et j'affinerai ma connaissance au fur et à mesure. Dans
l'extrait de code :
Volumetric* create(Kind k){
Volumetric* v;
switch (k) {
case RAW:
v =new RawVolumetric;break;
default:
v =NULL;break;
}
return v;
}
il y a un v=NULL qui ne me semble pas très joli.
Il faudrait tout du moins que je le caste en Volumetric*, non ?
Et si oui, quel operateur dois-je utiliser ?
Plutot que de relire pour la dixième fois le 30 chapitres et
tutoriaux sur les cast, auxquels je n'ai toujours rien panné, j'ai
décidé de changer de technique : je pose la question sur un cas
concret et j'affinerai ma connaissance au fur et à mesure. Dans
l'extrait de code :
Volumetric* create(Kind k){
Volumetric* v;
switch (k) {
case RAW:
v =new RawVolumetric;break;
default:
v =NULL;break;
}
return v;
}
il y a un v=NULL qui ne me semble pas très joli.
Il faudrait tout du moins que je le caste en Volumetric*, non ?
Et si oui, quel operateur dois-je utiliser ?
Plutot que de relire pour la dixième fois le 30 chapitres et
tutoriaux sur les cast, auxquels je n'ai toujours rien panné, j'ai
décidé de changer de technique : je pose la question sur un cas
concret et j'affinerai ma connaissance au fur et à mesure. Dans
l'extrait de code :
Volumetric* create(Kind k){
Volumetric* v;
switch (k) {
case RAW:
v =new RawVolumetric;break;
default:
v =NULL;break;
}
return v;
}
il y a un v=NULL qui ne me semble pas très joli.
Il faudrait tout du moins que je le caste en Volumetric*, non ?
Et si oui, quel operateur dois-je utiliser ?
On 13 Jul 2006 08:37:41 -0700, "meow" :
Volumetric* create(Kind k){
Volumetric* v;
Ça ne répond pas directement à ta question, mais j'aurais tendance à
mettre le 0/NULL ici :
Volumetric* create(Kind k)
{
Volumetric* v= 0;
D'une manière générale, je n'aime pas avoir une variable non
initialisée.
En prime, ici, on a une valeur par défaut toute trouvée (0/NULL),
qu'on ne modifie que si on a effectivement une nouvelle valeur.
La fonction devient alors :
Volumetric* create (Kind k)
{
Volumetric* v= 0;
switch (k)
{
case RAW: v= new RawVolumetric;break;
}
return v;
}
Note qu'à tout moment, v est un pointeur valide, sur lequel on peut
appeler delete sans problème.
J'aurais tendance à écrire
Volumetric* create (Kind k)
{
switch (k)
{
case RAW: return new RawVolumetric;
}
return 0;
}
mais certains n'aiment pas les fonctions avec plusieurs "return" ;
j'avoue ne pas trop savoir pourquoi.
On 13 Jul 2006 08:37:41 -0700, "meow" <schwarz.ben@gmail.com>:
Volumetric* create(Kind k){
Volumetric* v;
Ça ne répond pas directement à ta question, mais j'aurais tendance à
mettre le 0/NULL ici :
Volumetric* create(Kind k)
{
Volumetric* v= 0;
D'une manière générale, je n'aime pas avoir une variable non
initialisée.
En prime, ici, on a une valeur par défaut toute trouvée (0/NULL),
qu'on ne modifie que si on a effectivement une nouvelle valeur.
La fonction devient alors :
Volumetric* create (Kind k)
{
Volumetric* v= 0;
switch (k)
{
case RAW: v= new RawVolumetric;break;
}
return v;
}
Note qu'à tout moment, v est un pointeur valide, sur lequel on peut
appeler delete sans problème.
J'aurais tendance à écrire
Volumetric* create (Kind k)
{
switch (k)
{
case RAW: return new RawVolumetric;
}
return 0;
}
mais certains n'aiment pas les fonctions avec plusieurs "return" ;
j'avoue ne pas trop savoir pourquoi.
On 13 Jul 2006 08:37:41 -0700, "meow" :
Volumetric* create(Kind k){
Volumetric* v;
Ça ne répond pas directement à ta question, mais j'aurais tendance à
mettre le 0/NULL ici :
Volumetric* create(Kind k)
{
Volumetric* v= 0;
D'une manière générale, je n'aime pas avoir une variable non
initialisée.
En prime, ici, on a une valeur par défaut toute trouvée (0/NULL),
qu'on ne modifie que si on a effectivement une nouvelle valeur.
La fonction devient alors :
Volumetric* create (Kind k)
{
Volumetric* v= 0;
switch (k)
{
case RAW: v= new RawVolumetric;break;
}
return v;
}
Note qu'à tout moment, v est un pointeur valide, sur lequel on peut
appeler delete sans problème.
J'aurais tendance à écrire
Volumetric* create (Kind k)
{
switch (k)
{
case RAW: return new RawVolumetric;
}
return 0;
}
mais certains n'aiment pas les fonctions avec plusieurs "return" ;
j'avoue ne pas trop savoir pourquoi.
(Il y a eu
une discussion récemment dans le groupe anglophone, du fait que
« (0, 0) » n'est pas, malgré les apparences, une expression
constante entière.)
(Note bien aussi que si tu fais un « reinterpret_cast » d'une
variable de type int, dont la valeur est 0, ce n'est pas garantie
que tu ais le même résultat que si tu as une expression constante
qui vaut 0.)
(Il y a eu
une discussion récemment dans le groupe anglophone, du fait que
« (0, 0) » n'est pas, malgré les apparences, une expression
constante entière.)
(Note bien aussi que si tu fais un « reinterpret_cast » d'une
variable de type int, dont la valeur est 0, ce n'est pas garantie
que tu ais le même résultat que si tu as une expression constante
qui vaut 0.)
(Il y a eu
une discussion récemment dans le groupe anglophone, du fait que
« (0, 0) » n'est pas, malgré les apparences, une expression
constante entière.)
(Note bien aussi que si tu fais un « reinterpret_cast » d'une
variable de type int, dont la valeur est 0, ce n'est pas garantie
que tu ais le même résultat que si tu as une expression constante
qui vaut 0.)
mais certains n'aiment pas les fonctions avec plusieurs "return" ;
j'avoue ne pas trop savoir pourquoi.
Parce qu'on aime pouvoir raisonner de façon rigueureuse sur la
correction du code.
Ce qui ne veut pas dire qu'on n'admet pas d'exception.
mais certains n'aiment pas les fonctions avec plusieurs "return" ;
j'avoue ne pas trop savoir pourquoi.
Parce qu'on aime pouvoir raisonner de façon rigueureuse sur la
correction du code.
Ce qui ne veut pas dire qu'on n'admet pas d'exception.
mais certains n'aiment pas les fonctions avec plusieurs "return" ;
j'avoue ne pas trop savoir pourquoi.
Parce qu'on aime pouvoir raisonner de façon rigueureuse sur la
correction du code.
Ce qui ne veut pas dire qu'on n'admet pas d'exception.