Petite questions technique : je ne comprends pas pourquoi, dans ce code
"t2" est NULL.
C'est du code VC++ mais j'imagine que le problème sera le même avec un
autre compilateur...
Ce que tu voudrais, c'est que Factory2 affecte une valeur dans t2. Mais pour cela il faut que Factory ait l'adresse de t2 (t2 est une variable locale de main). Il y a deux solutions :
- la version "old school" pour les nostalgiques de C (dont moi) :
static void Factory2(Test * * t ) // un pointeur vers un pointeur { *t = new Test; } ... Test::Factory2(&t2); // on ne passe pas la valeur de t2, // mais l'adresse de t2 // (en fait la valeur de l'adresse de t2)
P/S: si tu veux un conseil : ne passe pas à autre chose avant d'avoir compris ça. C'est fondamental en C++. Et dans des tas d'autres langage s, même quand ils ne parlent pas de pointeurs.
Ce que tu voudrais, c'est que Factory2 affecte une valeur dans t2. Mais
pour cela il faut que Factory ait l'adresse de t2 (t2 est une variable
locale de main). Il y a deux solutions :
- la version "old school" pour les nostalgiques de C (dont moi) :
static void Factory2(Test * * t ) // un pointeur vers un pointeur
{
*t = new Test;
}
...
Test::Factory2(&t2); // on ne passe pas la valeur de t2,
// mais l'adresse de t2
// (en fait la valeur de l'adresse de t2)
P/S: si tu veux un conseil : ne passe pas à autre chose avant d'avoir
compris ça. C'est fondamental en C++. Et dans des tas d'autres langage s,
même quand ils ne parlent pas de pointeurs.
Ce que tu voudrais, c'est que Factory2 affecte une valeur dans t2. Mais pour cela il faut que Factory ait l'adresse de t2 (t2 est une variable locale de main). Il y a deux solutions :
- la version "old school" pour les nostalgiques de C (dont moi) :
static void Factory2(Test * * t ) // un pointeur vers un pointeur { *t = new Test; } ... Test::Factory2(&t2); // on ne passe pas la valeur de t2, // mais l'adresse de t2 // (en fait la valeur de l'adresse de t2)
P/S: si tu veux un conseil : ne passe pas à autre chose avant d'avoir compris ça. C'est fondamental en C++. Et dans des tas d'autres langage s, même quand ils ne parlent pas de pointeurs.
TSalm
static void Factory2(Test* t) { t = new Test; }
Ici t est un paramètre de Factory2, c'est donc essentiellement une variable locale. Tu peux la modifier comme tu veux, mais tu es dans un bac à sable (le contexte d'exécution de Factory2, qui disparaît à la fin de l'appel).
Ici tu appelles Factory2 en lui passant la *valeur* de t2 (qui donne sa valeur à t dans le corps de Factory2).
Tu n'as fait que passer des valeurs de pointeurs (tu as "recopié" t2 dans t, d'une certaine façon).
Ce que tu voudrais, c'est que Factory2 affecte une valeur dans t2. Mais pour cela il faut que Factory ait l'adresse de t2 (t2 est une variable locale de main). Il y a deux solutions :
- la version "old school" pour les nostalgiques de C (dont moi) :
static void Factory2(Test * * t ) // un pointeur vers un pointeur { *t = new Test; } ... Test::Factory2(&t2); // on ne passe pas la valeur de t2, // mais l'adresse de t2 // (en fait la valeur de l'adresse de t2)
- la version ultra-moderne :
static void Factory2(Test * & t) // une référence vers un pointeur { t = new Test; } ... Test::Factory2(t2); // comme Factory2 prend une référence, c'est // bien l'adresse qui est passée, pas la valeur
Dans les deux cas, on passe à Factory2 une "adresse", qui lui permet de modifier la variable dont on a passé l'adresse. C'est moins frappant dans le second, plus visible dans le premier cas.
Oui, ça fait deux niveaux d'indirection (on passe l'adresse d'un pointeur). Si tu trouves ça compliqué, remplace "Test *" (Test suivi d'une étoile) par pointeur_t.
-- Alain.
P/S: si tu veux un conseil : ne passe pas à autre chose avant d'avoir compris ça. C'est fondamental en C++. Et dans des tas d'autres langages, même quand ils ne parlent pas de pointeurs.
Merci pour tes explications. Il y a par contre quelquechose qui ne me parait pas très clair : - si je déclare "void Func1(int a)", il va dupliquer le valeur du int de l'appelant dans la variable "a" locale. - si je reprends la même règles, pourquoi la fonction "void Func1(int* a)" ne va pas copier la valeur du pointeur, qui est _l'adresse_ d'une variable pointant vers un int de l'appelant ?
static void Factory2(Test* t)
{
t = new Test;
}
Ici t est un paramètre de Factory2, c'est donc essentiellement une
variable locale. Tu peux la modifier comme tu veux, mais tu es dans un
bac à sable (le contexte d'exécution de Factory2, qui disparaît à la fin
de l'appel).
Ici tu appelles Factory2 en lui passant la *valeur* de t2 (qui donne sa
valeur à t dans le corps de Factory2).
Tu n'as fait que passer des valeurs de pointeurs (tu as "recopié" t2
dans t, d'une certaine façon).
Ce que tu voudrais, c'est que Factory2 affecte une valeur dans t2. Mais
pour cela il faut que Factory ait l'adresse de t2 (t2 est une variable
locale de main). Il y a deux solutions :
- la version "old school" pour les nostalgiques de C (dont moi) :
static void Factory2(Test * * t ) // un pointeur vers un pointeur
{
*t = new Test;
}
...
Test::Factory2(&t2); // on ne passe pas la valeur de t2,
// mais l'adresse de t2
// (en fait la valeur de l'adresse de t2)
- la version ultra-moderne :
static void Factory2(Test * & t) // une référence vers un pointeur
{
t = new Test;
}
...
Test::Factory2(t2); // comme Factory2 prend une référence, c'est
// bien l'adresse qui est passée, pas la valeur
Dans les deux cas, on passe à Factory2 une "adresse", qui lui permet de
modifier la variable dont on a passé l'adresse. C'est moins frappant
dans le second, plus visible dans le premier cas.
Oui, ça fait deux niveaux d'indirection (on passe l'adresse d'un
pointeur). Si tu trouves ça compliqué, remplace "Test *" (Test suivi
d'une étoile) par pointeur_t.
-- Alain.
P/S: si tu veux un conseil : ne passe pas à autre chose avant d'avoir
compris ça. C'est fondamental en C++. Et dans des tas d'autres langages,
même quand ils ne parlent pas de pointeurs.
Merci pour tes explications.
Il y a par contre quelquechose qui ne me parait pas très clair :
- si je déclare "void Func1(int a)", il va dupliquer le valeur du int de
l'appelant dans la variable "a" locale.
- si je reprends la même règles, pourquoi la fonction "void Func1(int*
a)" ne va pas copier la valeur du pointeur, qui est _l'adresse_ d'une
variable pointant vers un int de l'appelant ?
Ici t est un paramètre de Factory2, c'est donc essentiellement une variable locale. Tu peux la modifier comme tu veux, mais tu es dans un bac à sable (le contexte d'exécution de Factory2, qui disparaît à la fin de l'appel).
Ici tu appelles Factory2 en lui passant la *valeur* de t2 (qui donne sa valeur à t dans le corps de Factory2).
Tu n'as fait que passer des valeurs de pointeurs (tu as "recopié" t2 dans t, d'une certaine façon).
Ce que tu voudrais, c'est que Factory2 affecte une valeur dans t2. Mais pour cela il faut que Factory ait l'adresse de t2 (t2 est une variable locale de main). Il y a deux solutions :
- la version "old school" pour les nostalgiques de C (dont moi) :
static void Factory2(Test * * t ) // un pointeur vers un pointeur { *t = new Test; } ... Test::Factory2(&t2); // on ne passe pas la valeur de t2, // mais l'adresse de t2 // (en fait la valeur de l'adresse de t2)
- la version ultra-moderne :
static void Factory2(Test * & t) // une référence vers un pointeur { t = new Test; } ... Test::Factory2(t2); // comme Factory2 prend une référence, c'est // bien l'adresse qui est passée, pas la valeur
Dans les deux cas, on passe à Factory2 une "adresse", qui lui permet de modifier la variable dont on a passé l'adresse. C'est moins frappant dans le second, plus visible dans le premier cas.
Oui, ça fait deux niveaux d'indirection (on passe l'adresse d'un pointeur). Si tu trouves ça compliqué, remplace "Test *" (Test suivi d'une étoile) par pointeur_t.
-- Alain.
P/S: si tu veux un conseil : ne passe pas à autre chose avant d'avoir compris ça. C'est fondamental en C++. Et dans des tas d'autres langages, même quand ils ne parlent pas de pointeurs.
Merci pour tes explications. Il y a par contre quelquechose qui ne me parait pas très clair : - si je déclare "void Func1(int a)", il va dupliquer le valeur du int de l'appelant dans la variable "a" locale. - si je reprends la même règles, pourquoi la fonction "void Func1(int* a)" ne va pas copier la valeur du pointeur, qui est _l'adresse_ d'une variable pointant vers un int de l'appelant ?
- si je reprends la même règles, pourquoi la fonction "void Func1(int* a)" ne va pas copier la valeur du pointeur, qui est _l'adresse_ d'une variable pointant vers un int de l'appelant ?
Non, ce n'est pas l'adresse d'une variable pointant vers un int, c'est l'adresse d'un int.
L'adresse d'une variable pointant vers un int, ce serait int ** p.
- si je reprends la même règles, pourquoi la fonction "void
Func1(int* a)" ne va pas copier la valeur du pointeur, qui est
_l'adresse_ d'une variable pointant vers un int de l'appelant ?
Non, ce n'est pas l'adresse d'une variable pointant vers un int, c'est
l'adresse d'un int.
L'adresse d'une variable pointant vers un int, ce serait int ** p.
- si je reprends la même règles, pourquoi la fonction "void Func1(int* a)" ne va pas copier la valeur du pointeur, qui est _l'adresse_ d'une variable pointant vers un int de l'appelant ?
Non, ce n'est pas l'adresse d'une variable pointant vers un int, c'est l'adresse d'un int.
L'adresse d'une variable pointant vers un int, ce serait int ** p.
- si je reprends la même règles, pourquoi la fonction "void Func1(int* a)" ne va pas copier la valeur du pointeur, qui est _l'adresse_ d'une variable pointant vers un int de l'appelant ?
Non, ce n'est pas l'adresse d'une variable pointant vers un int, c'est l'adresse d'un int.
L'adresse d'une variable pointant vers un int, ce serait int ** p.
Je comprends : 1- On commence par passer à la méthode un pointeur pointant vers NULL. 2- Il créé un pointeur et copie sa valeur pointée (qui est égale NULL) 3- Le "new" valorise ce pointeur avec une autre valeur 4- Par contre, le pointeur de l'appelant pointe toujours vers NULL puisque ce n"est pas la même variable
Merci pour ces excellentes explications !
- si je reprends la même règles, pourquoi la fonction "void
Func1(int* a)" ne va pas copier la valeur du pointeur, qui est
_l'adresse_ d'une variable pointant vers un int de l'appelant ?
Non, ce n'est pas l'adresse d'une variable pointant vers un int, c'est
l'adresse d'un int.
L'adresse d'une variable pointant vers un int, ce serait int ** p.
Je comprends :
1- On commence par passer à la méthode un pointeur pointant vers NULL.
2- Il créé un pointeur et copie sa valeur pointée (qui est égale NULL)
3- Le "new" valorise ce pointeur avec une autre valeur
4- Par contre, le pointeur de l'appelant pointe toujours vers NULL
puisque ce n"est pas la même variable
- si je reprends la même règles, pourquoi la fonction "void Func1(int* a)" ne va pas copier la valeur du pointeur, qui est _l'adresse_ d'une variable pointant vers un int de l'appelant ?
Non, ce n'est pas l'adresse d'une variable pointant vers un int, c'est l'adresse d'un int.
L'adresse d'une variable pointant vers un int, ce serait int ** p.
Je comprends : 1- On commence par passer à la méthode un pointeur pointant vers NULL. 2- Il créé un pointeur et copie sa valeur pointée (qui est égale NULL) 3- Le "new" valorise ce pointeur avec une autre valeur 4- Par contre, le pointeur de l'appelant pointe toujours vers NULL puisque ce n"est pas la même variable