j'ai une classe dont les objets peuvent etre construits en specifiant ou
non le dernier parametre qui est un std::vector. J'avais donc simplement
utilise un parametre par defaut qui mettait le vector vide s'il n'etait
pas initialise. Mais dernierement, on me dit (avec des explications
fumeuses que je n'ai pas comprises...) qu'il fallait pas faire ca. Je me
retrouve donc a faire 2 constructeurs appelant une fonction init. Celui
qui n'a pas le parametre associe au vector le cree simplement (vide) et
appelle la fonction init. Je trouve ca plus que douteux comme solution.
Alors pourquoi la premiere solution n'etait pas correcte?
J'avais donc simplement utilise un parametre par defaut qui mettait le vector vide s'il n'etait pas initialise. Mais dernierement, on me dit (avec des explications fumeuses que je n'ai pas comprises...) qu'il fallait pas faire ca.
Ah ? Je veux bien voir les explications en question. Personnellement, la construction suivante ne m'a jamais gêné :
class C { public: C (int i, std::vector<double> v= std::vector<double>()); };
-- ;-)
On Tue, 04 Jan 2005 13:29:38 +0100, korchkidu <korch_ki_du@yahoo.fr>:
J'avais donc simplement
utilise un parametre par defaut qui mettait le vector vide s'il n'etait
pas initialise. Mais dernierement, on me dit (avec des explications
fumeuses que je n'ai pas comprises...) qu'il fallait pas faire ca.
Ah ? Je veux bien voir les explications en question.
Personnellement, la construction suivante ne m'a jamais gêné :
class C
{
public:
C (int i, std::vector<double> v= std::vector<double>());
};
J'avais donc simplement utilise un parametre par defaut qui mettait le vector vide s'il n'etait pas initialise. Mais dernierement, on me dit (avec des explications fumeuses que je n'ai pas comprises...) qu'il fallait pas faire ca.
Ah ? Je veux bien voir les explications en question. Personnellement, la construction suivante ne m'a jamais gêné :
class C { public: C (int i, std::vector<double> v= std::vector<double>()); };
-- ;-)
Fabien LE LEZ
On Tue, 04 Jan 2005 13:29:38 +0100, korchkidu :
J'avais donc simplement utilise un parametre par defaut qui mettait le vector vide s'il n'etait pas initialise. Mais dernierement, on me dit (avec des explications fumeuses que je n'ai pas comprises...) qu'il fallait pas faire ca.
Ah ? Je veux bien voir les explications en question. Personnellement, la construction suivante ne m'a jamais gêné :
class C { public: C (int i, std::vector<double> const& v= std::vector<double>()); };
-- ;-)
On Tue, 04 Jan 2005 13:29:38 +0100, korchkidu <korch_ki_du@yahoo.fr>:
J'avais donc simplement
utilise un parametre par defaut qui mettait le vector vide s'il n'etait
pas initialise. Mais dernierement, on me dit (avec des explications
fumeuses que je n'ai pas comprises...) qu'il fallait pas faire ca.
Ah ? Je veux bien voir les explications en question.
Personnellement, la construction suivante ne m'a jamais gêné :
class C
{
public:
C (int i, std::vector<double> const& v= std::vector<double>());
};
J'avais donc simplement utilise un parametre par defaut qui mettait le vector vide s'il n'etait pas initialise. Mais dernierement, on me dit (avec des explications fumeuses que je n'ai pas comprises...) qu'il fallait pas faire ca.
Ah ? Je veux bien voir les explications en question. Personnellement, la construction suivante ne m'a jamais gêné :
class C { public: C (int i, std::vector<double> const& v= std::vector<double>()); };
-- ;-)
Jean-Marc Bourguet
korchkidu writes:
j'ai une classe dont les objets peuvent etre construits en specifiant ou non le dernier parametre qui est un std::vector. J'avais donc simplement utilise un parametre par defaut qui mettait le vector vide s'il n'etait pas initialise. Mais dernierement, on me dit (avec des explications fumeuses que je n'ai pas comprises...) qu'il fallait pas faire ca. Je me retrouve donc a faire 2 constructeurs appelant une fonction init. Celui qui n'a pas le parametre associe au vector le cree simplement (vide) et appelle la fonction init. Je trouve ca plus que douteux comme solution. Alors pourquoi la premiere solution n'etait pas correcte?
La seule raison que je vois de preferer la surcharge aux parametres avec des valeurs par defaut (mais je n'ai pas reflechi longtemps a la question), c'est la possibilite de prendre des pointeurs vers fonctions vers toutes les signatures. Cette raison n'est pas valable pour les constructeurs pour lesquels a priori j'utiliserais des parametre ayant des valeurs par defaut sans etats d'ame.
Sans connaitre les raisons qui t'ont ete donnees (etaient elles generiques ou propres au cas en presence?), c'est difficile de commenter plus.
A+
-- Jean-Marc FAQ de fclc++: http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ C++ FAQ Lite en VF: http://www.ifrance.com/jlecomte/c++/c++-faq-lite/index.html Site de usenet-fr: http://www.usenet-fr.news.eu.org
korchkidu <korch_ki_du@yahoo.fr> writes:
j'ai une classe dont les objets peuvent etre construits en
specifiant ou non le dernier parametre qui est un
std::vector. J'avais donc simplement utilise un parametre par defaut
qui mettait le vector vide s'il n'etait pas initialise. Mais
dernierement, on me dit (avec des explications fumeuses que je n'ai
pas comprises...) qu'il fallait pas faire ca. Je me retrouve donc a
faire 2 constructeurs appelant une fonction init. Celui qui n'a pas
le parametre associe au vector le cree simplement (vide) et appelle
la fonction init. Je trouve ca plus que douteux comme
solution. Alors pourquoi la premiere solution n'etait pas correcte?
La seule raison que je vois de preferer la surcharge aux parametres
avec des valeurs par defaut (mais je n'ai pas reflechi longtemps a la
question), c'est la possibilite de prendre des pointeurs vers
fonctions vers toutes les signatures. Cette raison n'est pas valable
pour les constructeurs pour lesquels a priori j'utiliserais des
parametre ayant des valeurs par defaut sans etats d'ame.
Sans connaitre les raisons qui t'ont ete donnees (etaient elles
generiques ou propres au cas en presence?), c'est difficile de
commenter plus.
A+
--
Jean-Marc
FAQ de fclc++: http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ
C++ FAQ Lite en VF: http://www.ifrance.com/jlecomte/c++/c++-faq-lite/index.html
Site de usenet-fr: http://www.usenet-fr.news.eu.org
j'ai une classe dont les objets peuvent etre construits en specifiant ou non le dernier parametre qui est un std::vector. J'avais donc simplement utilise un parametre par defaut qui mettait le vector vide s'il n'etait pas initialise. Mais dernierement, on me dit (avec des explications fumeuses que je n'ai pas comprises...) qu'il fallait pas faire ca. Je me retrouve donc a faire 2 constructeurs appelant une fonction init. Celui qui n'a pas le parametre associe au vector le cree simplement (vide) et appelle la fonction init. Je trouve ca plus que douteux comme solution. Alors pourquoi la premiere solution n'etait pas correcte?
La seule raison que je vois de preferer la surcharge aux parametres avec des valeurs par defaut (mais je n'ai pas reflechi longtemps a la question), c'est la possibilite de prendre des pointeurs vers fonctions vers toutes les signatures. Cette raison n'est pas valable pour les constructeurs pour lesquels a priori j'utiliserais des parametre ayant des valeurs par defaut sans etats d'ame.
Sans connaitre les raisons qui t'ont ete donnees (etaient elles generiques ou propres au cas en presence?), c'est difficile de commenter plus.
A+
-- Jean-Marc FAQ de fclc++: http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ C++ FAQ Lite en VF: http://www.ifrance.com/jlecomte/c++/c++-faq-lite/index.html Site de usenet-fr: http://www.usenet-fr.news.eu.org
Marc Boyer
In article , Jean-Marc Bourguet wrote:
korchkidu writes:
j'ai une classe dont les objets peuvent etre construits en specifiant ou non le dernier parametre qui est un std::vector. J'avais donc simplement utilise un parametre par defaut qui mettait le vector vide s'il n'etait pas initialise. Mais dernierement, on me dit (avec des explications fumeuses que je n'ai pas comprises...) qu'il fallait pas faire ca. Je me retrouve donc a faire 2 constructeurs appelant une fonction init. Celui qui n'a pas le parametre associe au vector le cree simplement (vide) et appelle la fonction init. Je trouve ca plus que douteux comme solution. Alors pourquoi la premiere solution n'etait pas correcte?
La seule raison que je vois de preferer la surcharge aux parametres avec des valeurs par defaut (mais je n'ai pas reflechi longtemps a la question), c'est la possibilite de prendre des pointeurs vers fonctions vers toutes les signatures. Cette raison n'est pas valable pour les constructeurs pour lesquels a priori j'utiliserais des parametre ayant des valeurs par defaut sans etats d'ame.
C'est à dire qu'on ne peut pas faire: void foo(int i, double d=0); typedef (*fun_i)(int); typedef (*fun_i_d)(int,double);
fun_i fi= foo; fun_i_di fid= foo;
Marc Boyer -- Je ne respecte plus le code de la route à vélo depuis une double fracture due au fait que j'étais le seul à le respecter.
In article <pxbllb99xfl.fsf@news.bourguet.org>, Jean-Marc Bourguet wrote:
korchkidu <korch_ki_du@yahoo.fr> writes:
j'ai une classe dont les objets peuvent etre construits en
specifiant ou non le dernier parametre qui est un
std::vector. J'avais donc simplement utilise un parametre par defaut
qui mettait le vector vide s'il n'etait pas initialise. Mais
dernierement, on me dit (avec des explications fumeuses que je n'ai
pas comprises...) qu'il fallait pas faire ca. Je me retrouve donc a
faire 2 constructeurs appelant une fonction init. Celui qui n'a pas
le parametre associe au vector le cree simplement (vide) et appelle
la fonction init. Je trouve ca plus que douteux comme
solution. Alors pourquoi la premiere solution n'etait pas correcte?
La seule raison que je vois de preferer la surcharge aux parametres
avec des valeurs par defaut (mais je n'ai pas reflechi longtemps a la
question), c'est la possibilite de prendre des pointeurs vers
fonctions vers toutes les signatures. Cette raison n'est pas valable
pour les constructeurs pour lesquels a priori j'utiliserais des
parametre ayant des valeurs par defaut sans etats d'ame.
C'est à dire qu'on ne peut pas faire:
void foo(int i, double d=0);
typedef (*fun_i)(int);
typedef (*fun_i_d)(int,double);
fun_i fi= foo;
fun_i_di fid= foo;
Marc Boyer
--
Je ne respecte plus le code de la route à vélo depuis une double fracture
due au fait que j'étais le seul à le respecter.
j'ai une classe dont les objets peuvent etre construits en specifiant ou non le dernier parametre qui est un std::vector. J'avais donc simplement utilise un parametre par defaut qui mettait le vector vide s'il n'etait pas initialise. Mais dernierement, on me dit (avec des explications fumeuses que je n'ai pas comprises...) qu'il fallait pas faire ca. Je me retrouve donc a faire 2 constructeurs appelant une fonction init. Celui qui n'a pas le parametre associe au vector le cree simplement (vide) et appelle la fonction init. Je trouve ca plus que douteux comme solution. Alors pourquoi la premiere solution n'etait pas correcte?
La seule raison que je vois de preferer la surcharge aux parametres avec des valeurs par defaut (mais je n'ai pas reflechi longtemps a la question), c'est la possibilite de prendre des pointeurs vers fonctions vers toutes les signatures. Cette raison n'est pas valable pour les constructeurs pour lesquels a priori j'utiliserais des parametre ayant des valeurs par defaut sans etats d'ame.
C'est à dire qu'on ne peut pas faire: void foo(int i, double d=0); typedef (*fun_i)(int); typedef (*fun_i_d)(int,double);
fun_i fi= foo; fun_i_di fid= foo;
Marc Boyer -- Je ne respecte plus le code de la route à vélo depuis une double fracture due au fait que j'étais le seul à le respecter.
Jean-Marc Bourguet
Marc Boyer writes:
La seule raison que je vois de preferer la surcharge aux parametres avec des valeurs par defaut (mais je n'ai pas reflechi longtemps a la question), c'est la possibilite de prendre des pointeurs vers fonctions vers toutes les signatures. Cette raison n'est pas valable pour les constructeurs pour lesquels a priori j'utiliserais des parametre ayant des valeurs par defaut sans etats d'ame.
C'est à dire qu'on ne peut pas faire: void foo(int i, double d=0); typedef (*fun_i)(int); typedef (*fun_i_d)(int,double);
fun_i fi= foo; fun_i_di fid= foo;
Exact.
A+
-- Jean-Marc FAQ de fclc++: http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ C++ FAQ Lite en VF: http://www.ifrance.com/jlecomte/c++/c++-faq-lite/index.html Site de usenet-fr: http://www.usenet-fr.news.eu.org
Marc Boyer <Marc.Boyer@enseeiht.yahoo.fr.invalid> writes:
La seule raison que je vois de preferer la surcharge aux parametres
avec des valeurs par defaut (mais je n'ai pas reflechi longtemps a la
question), c'est la possibilite de prendre des pointeurs vers
fonctions vers toutes les signatures. Cette raison n'est pas valable
pour les constructeurs pour lesquels a priori j'utiliserais des
parametre ayant des valeurs par defaut sans etats d'ame.
C'est à dire qu'on ne peut pas faire:
void foo(int i, double d=0);
typedef (*fun_i)(int);
typedef (*fun_i_d)(int,double);
fun_i fi= foo;
fun_i_di fid= foo;
Exact.
A+
--
Jean-Marc
FAQ de fclc++: http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ
C++ FAQ Lite en VF: http://www.ifrance.com/jlecomte/c++/c++-faq-lite/index.html
Site de usenet-fr: http://www.usenet-fr.news.eu.org
La seule raison que je vois de preferer la surcharge aux parametres avec des valeurs par defaut (mais je n'ai pas reflechi longtemps a la question), c'est la possibilite de prendre des pointeurs vers fonctions vers toutes les signatures. Cette raison n'est pas valable pour les constructeurs pour lesquels a priori j'utiliserais des parametre ayant des valeurs par defaut sans etats d'ame.
C'est à dire qu'on ne peut pas faire: void foo(int i, double d=0); typedef (*fun_i)(int); typedef (*fun_i_d)(int,double);
fun_i fi= foo; fun_i_di fid= foo;
Exact.
A+
-- Jean-Marc FAQ de fclc++: http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ C++ FAQ Lite en VF: http://www.ifrance.com/jlecomte/c++/c++-faq-lite/index.html Site de usenet-fr: http://www.usenet-fr.news.eu.org
korchkidu
Fabien LE LEZ wrote:
On Tue, 04 Jan 2005 13:29:38 +0100, korchkidu :
J'avais donc simplement utilise un parametre par defaut qui mettait le vector vide s'il n'etait pas initialise. Mais dernierement, on me dit (avec des explications fumeuses que je n'ai pas comprises...) qu'il fallait pas faire ca.
Ah ? Je veux bien voir les explications en question.
Apres avoir redemande a la personne en question, le vector serait cree sur la pile ce qui pourrait causer des problemes lors de la destruction (lorsque la fonction retourne)...C'est pas plus clair que ca...
Le mot de la fin etant "This is definitely not a good way how to ensure that something is initialized. ".
K.
Fabien LE LEZ wrote:
On Tue, 04 Jan 2005 13:29:38 +0100, korchkidu <korch_ki_du@yahoo.fr>:
J'avais donc simplement
utilise un parametre par defaut qui mettait le vector vide s'il n'etait
pas initialise. Mais dernierement, on me dit (avec des explications
fumeuses que je n'ai pas comprises...) qu'il fallait pas faire ca.
Ah ? Je veux bien voir les explications en question.
Apres avoir redemande a la personne en question, le vector serait cree
sur la pile ce qui pourrait causer des problemes lors de la destruction
(lorsque la fonction retourne)...C'est pas plus clair que ca...
Le mot de la fin etant "This is definitely not a good way how to
ensure that something is initialized.
".
J'avais donc simplement utilise un parametre par defaut qui mettait le vector vide s'il n'etait pas initialise. Mais dernierement, on me dit (avec des explications fumeuses que je n'ai pas comprises...) qu'il fallait pas faire ca.
Ah ? Je veux bien voir les explications en question.
Apres avoir redemande a la personne en question, le vector serait cree sur la pile ce qui pourrait causer des problemes lors de la destruction (lorsque la fonction retourne)...C'est pas plus clair que ca...
Le mot de la fin etant "This is definitely not a good way how to ensure that something is initialized. ".
K.
korchkidu
Marc Boyer wrote:
In article , Jean-Marc Bourguet wrote:
korchkidu writes:
j'ai une classe dont les objets peuvent etre construits en specifiant ou non le dernier parametre qui est un std::vector. J'avais donc simplement utilise un parametre par defaut qui mettait le vector vide s'il n'etait pas initialise. Mais dernierement, on me dit (avec des explications fumeuses que je n'ai pas comprises...) qu'il fallait pas faire ca. Je me retrouve donc a faire 2 constructeurs appelant une fonction init. Celui qui n'a pas le parametre associe au vector le cree simplement (vide) et appelle la fonction init. Je trouve ca plus que douteux comme solution. Alors pourquoi la premiere solution n'etait pas correcte?
La seule raison que je vois de preferer la surcharge aux parametres avec des valeurs par defaut (mais je n'ai pas reflechi longtemps a la question), c'est la possibilite de prendre des pointeurs vers fonctions vers toutes les signatures. Cette raison n'est pas valable pour les constructeurs pour lesquels a priori j'utiliserais des parametre ayant des valeurs par defaut sans etats d'ame.
C'est à dire qu'on ne peut pas faire: void foo(int i, double d=0); typedef (*fun_i)(int); typedef (*fun_i_d)(int,double);
fun_i fi= foo; fun_i_di fid= foo;
Donc en restant dans le cas des objets, ca devrait marcher si je comprends bien...
Merci pour toutes vos reponses, K.
Marc Boyer wrote:
In article <pxbllb99xfl.fsf@news.bourguet.org>, Jean-Marc Bourguet wrote:
korchkidu <korch_ki_du@yahoo.fr> writes:
j'ai une classe dont les objets peuvent etre construits en
specifiant ou non le dernier parametre qui est un
std::vector. J'avais donc simplement utilise un parametre par defaut
qui mettait le vector vide s'il n'etait pas initialise. Mais
dernierement, on me dit (avec des explications fumeuses que je n'ai
pas comprises...) qu'il fallait pas faire ca. Je me retrouve donc a
faire 2 constructeurs appelant une fonction init. Celui qui n'a pas
le parametre associe au vector le cree simplement (vide) et appelle
la fonction init. Je trouve ca plus que douteux comme
solution. Alors pourquoi la premiere solution n'etait pas correcte?
La seule raison que je vois de preferer la surcharge aux parametres
avec des valeurs par defaut (mais je n'ai pas reflechi longtemps a la
question), c'est la possibilite de prendre des pointeurs vers
fonctions vers toutes les signatures. Cette raison n'est pas valable
pour les constructeurs pour lesquels a priori j'utiliserais des
parametre ayant des valeurs par defaut sans etats d'ame.
C'est à dire qu'on ne peut pas faire:
void foo(int i, double d=0);
typedef (*fun_i)(int);
typedef (*fun_i_d)(int,double);
fun_i fi= foo;
fun_i_di fid= foo;
Donc en restant dans le cas des objets, ca devrait marcher si je
comprends bien...
j'ai une classe dont les objets peuvent etre construits en specifiant ou non le dernier parametre qui est un std::vector. J'avais donc simplement utilise un parametre par defaut qui mettait le vector vide s'il n'etait pas initialise. Mais dernierement, on me dit (avec des explications fumeuses que je n'ai pas comprises...) qu'il fallait pas faire ca. Je me retrouve donc a faire 2 constructeurs appelant une fonction init. Celui qui n'a pas le parametre associe au vector le cree simplement (vide) et appelle la fonction init. Je trouve ca plus que douteux comme solution. Alors pourquoi la premiere solution n'etait pas correcte?
La seule raison que je vois de preferer la surcharge aux parametres avec des valeurs par defaut (mais je n'ai pas reflechi longtemps a la question), c'est la possibilite de prendre des pointeurs vers fonctions vers toutes les signatures. Cette raison n'est pas valable pour les constructeurs pour lesquels a priori j'utiliserais des parametre ayant des valeurs par defaut sans etats d'ame.
C'est à dire qu'on ne peut pas faire: void foo(int i, double d=0); typedef (*fun_i)(int); typedef (*fun_i_d)(int,double);
fun_i fi= foo; fun_i_di fid= foo;
Donc en restant dans le cas des objets, ca devrait marcher si je comprends bien...
Merci pour toutes vos reponses, K.
drkm
korchkidu writes:
Marc Boyer wrote:
C'est à dire qu'on ne peut pas faire: void foo(int i, double d=0); typedef (*fun_i)(int); typedef (*fun_i_d)(int,double); fun_i fi= foo; fun_i_di fid= foo;
Donc en restant dans le cas des objets, ca devrait marcher si je comprends bien...
Je ne comprend pas ce que tu veux dire ...
--drkm
korchkidu <korch_ki_du@yahoo.fr> writes:
Marc Boyer wrote:
C'est à dire qu'on ne peut pas faire:
void foo(int i, double d=0);
typedef (*fun_i)(int);
typedef (*fun_i_d)(int,double);
fun_i fi= foo;
fun_i_di fid= foo;
Donc en restant dans le cas des objets, ca devrait marcher si je
comprends bien...
C'est à dire qu'on ne peut pas faire: void foo(int i, double d=0); typedef (*fun_i)(int); typedef (*fun_i_d)(int,double); fun_i fi= foo; fun_i_di fid= foo;
Donc en restant dans le cas des objets, ca devrait marcher si je comprends bien...
Je ne comprend pas ce que tu veux dire ...
--drkm
drkm
korchkidu writes:
Fabien LE LEZ wrote:
On Tue, 04 Jan 2005 13:29:38 +0100, korchkidu :
J'avais donc simplement utilise un parametre par defaut qui mettait le vector vide s'il n'etait pas initialise. Mais dernierement, on me dit (avec des explications fumeuses que je n'ai pas comprises...) qu'il fallait pas faire ca.
Ah ? Je veux bien voir les explications en question.
Apres avoir redemande a la personne en question, le vector serait cree sur la pile ce qui pourrait causer des problemes lors de la destruction (lorsque la fonction retourne)...C'est pas plus clair que ca...
Mais de quels problèmes parle-t-elle ?
Le mot de la fin etant "This is definitely not a good way how to ensure that something is initialized. ".
Cette personne serait-elle intéressée à partager son point de vue ? J'avoue ne toujours pas voir de quels problèmes elle parle.
--drkm
korchkidu <korch_ki_du@yahoo.fr> writes:
Fabien LE LEZ wrote:
On Tue, 04 Jan 2005 13:29:38 +0100, korchkidu <korch_ki_du@yahoo.fr>:
J'avais donc simplement utilise un parametre par defaut qui mettait
le vector vide s'il n'etait pas initialise. Mais dernierement, on
me dit (avec des explications fumeuses que je n'ai pas
comprises...) qu'il fallait pas faire ca.
Ah ? Je veux bien voir les explications en question.
Apres avoir redemande a la personne en question, le vector serait cree
sur la pile ce qui pourrait causer des problemes lors de la destruction
(lorsque la fonction retourne)...C'est pas plus clair que ca...
Mais de quels problèmes parle-t-elle ?
Le mot de la fin etant "This is definitely not a good way how to
ensure that something is initialized.
".
Cette personne serait-elle intéressée à partager son point de vue ?
J'avoue ne toujours pas voir de quels problèmes elle parle.
J'avais donc simplement utilise un parametre par defaut qui mettait le vector vide s'il n'etait pas initialise. Mais dernierement, on me dit (avec des explications fumeuses que je n'ai pas comprises...) qu'il fallait pas faire ca.
Ah ? Je veux bien voir les explications en question.
Apres avoir redemande a la personne en question, le vector serait cree sur la pile ce qui pourrait causer des problemes lors de la destruction (lorsque la fonction retourne)...C'est pas plus clair que ca...
Mais de quels problèmes parle-t-elle ?
Le mot de la fin etant "This is definitely not a good way how to ensure that something is initialized. ".
Cette personne serait-elle intéressée à partager son point de vue ? J'avoue ne toujours pas voir de quels problèmes elle parle.
--drkm
Fabien LE LEZ
On Tue, 04 Jan 2005 18:19:36 +0100, korchkidu :
Apres avoir redemande a la personne en question, le vector serait cree sur la pile ce qui pourrait causer des problemes lors de la destruction (lorsque la fonction retourne)...C'est pas plus clair que ca...
Mouais... Rien de bien convaincant, en tout cas. Je te rassure, C++ gère parfaitement bien ce cas.
-- ;-)
On Tue, 04 Jan 2005 18:19:36 +0100, korchkidu <korch_ki_du@yahoo.fr>:
Apres avoir redemande a la personne en question, le vector serait cree
sur la pile ce qui pourrait causer des problemes lors de la destruction
(lorsque la fonction retourne)...C'est pas plus clair que ca...
Mouais... Rien de bien convaincant, en tout cas.
Je te rassure, C++ gère parfaitement bien ce cas.
Apres avoir redemande a la personne en question, le vector serait cree sur la pile ce qui pourrait causer des problemes lors de la destruction (lorsque la fonction retourne)...C'est pas plus clair que ca...
Mouais... Rien de bien convaincant, en tout cas. Je te rassure, C++ gère parfaitement bien ce cas.
