Personnellement, je réalise mes programmes avec DELPHI (langage Pascal de
BORLAND) où sont définis des "tableaux dynamiques". Ce sont des tableaux
dont on peut fixer la taille (le nombre d'éléments) à l'exécution.
J'utilise ce type de tableaux pour échanger des infos entre un programme et
des DLL.
Existe-t-il l'équivalent, pour ne pas dire la même chose, dans d'autres
langages, notamment le C++ de chez Microsoft.
Sinon, comment faites-vous pour échanger entre .exe et .dll quand vous ne
connaissez pas à la compilation la taille des infos à échanger ;le nombre de
pixels de l'image en cours de traitement par exemple.
Ce qui ne t'empêchera pas, ni moi, d'éventuellement écrire des bêtises.
Et c'est effectivement un des point sur lequel visual C++, dans ses anciennes versions, n'est pas conforme à la norme C++. Il existe peut-être un flag de compilation qui le rend conforme sur ce point.
Ben c'est tiré de la doc de mon Visual C++.Net 2002
In Visual C++ .NET 2002, the new function in the Standard C++ Library will support the behavior specified in the C++ standard, which is to throw a std::bad_alloc exception if the memory allocation fails.
Tiens donc, ça peut échouer un new alors :-) ?
9 [Example: T* p1 = new T; // throws bad_alloc if it fails T* p2 >> new(nothrow) T; // returns 0 if it fails —end example]
Bah oui, mais 0, j'appelle pas ça un pointeur valide moi. Je te répète ta phrase :
"new ne peut pas retourner autre chose qu'un pointeur valide"
0, c'est pas un pointeur valide.
-- AMcD®
http://arnold.mcdonald.free.fr/
Loïc Joly wrote:
Mouarf, t'es un grand comique toi.
Non, je suis juste quelqu'un qui connais le C++.
Ce qui ne t'empêchera pas, ni moi, d'éventuellement écrire des bêtises.
Et c'est effectivement un des point sur lequel visual C++, dans ses
anciennes versions, n'est pas conforme à la norme C++. Il existe
peut-être un flag de compilation qui le rend conforme sur ce point.
Ben c'est tiré de la doc de mon Visual C++.Net 2002
In Visual C++ .NET 2002, the new function in the Standard C++ Library
will support the behavior specified in the C++ standard, which is to
throw a std::bad_alloc exception if the memory allocation fails.
Tiens donc, ça peut échouer un new alors :-) ?
9 [Example: T* p1 = new T; // throws bad_alloc if it fails T* p2 >> new(nothrow) T; // returns 0 if it fails —end example]
Bah oui, mais 0, j'appelle pas ça un pointeur valide moi. Je te répète ta
phrase :
"new ne peut pas retourner autre chose qu'un pointeur valide"
Ce qui ne t'empêchera pas, ni moi, d'éventuellement écrire des bêtises.
Et c'est effectivement un des point sur lequel visual C++, dans ses anciennes versions, n'est pas conforme à la norme C++. Il existe peut-être un flag de compilation qui le rend conforme sur ce point.
Ben c'est tiré de la doc de mon Visual C++.Net 2002
In Visual C++ .NET 2002, the new function in the Standard C++ Library will support the behavior specified in the C++ standard, which is to throw a std::bad_alloc exception if the memory allocation fails.
Tiens donc, ça peut échouer un new alors :-) ?
9 [Example: T* p1 = new T; // throws bad_alloc if it fails T* p2 >> new(nothrow) T; // returns 0 if it fails —end example]
Bah oui, mais 0, j'appelle pas ça un pointeur valide moi. Je te répète ta phrase :
"new ne peut pas retourner autre chose qu'un pointeur valide"
0, c'est pas un pointeur valide.
-- AMcD®
http://arnold.mcdonald.free.fr/
Loïc Joly
AMcD® wrote:
Loïc Joly wrote:
Peut-être que sur certains compilateurs et avec certains types, ça va donner le résultat auquel tu t'attends (0 ?). Peut-être pas.
Ben j'espère que ça donne pas le bon résultat, vu qu'il faudrait écrire :
i = (int)u.d;
Cela revient à une discussion plus haut. Quand on programme comme une buse, on a des bugs :-).
Dans cette expression, peux tu me dire en quoi le fait que U soit une union intervient ? Ou alors me donner un meilleur exemple de ce que tu disait, je cite :
Je disais juste que les unions sont un excellent exemple de cast sauvage "à la volée".
-- Loïc
AMcD® wrote:
Loïc Joly wrote:
Peut-être que sur certains compilateurs et avec certains types, ça va
donner le résultat auquel tu t'attends (0 ?). Peut-être pas.
Ben j'espère que ça donne pas le bon résultat, vu qu'il faudrait écrire :
i = (int)u.d;
Cela revient à une discussion plus haut. Quand on programme comme une buse,
on a des bugs :-).
Dans cette expression, peux tu me dire en quoi le fait que U soit une
union intervient ? Ou alors me donner un meilleur exemple de ce que tu
disait, je cite :
Je disais juste que les unions sont un excellent exemple de
cast sauvage "à la volée".
Peut-être que sur certains compilateurs et avec certains types, ça va donner le résultat auquel tu t'attends (0 ?). Peut-être pas.
Ben j'espère que ça donne pas le bon résultat, vu qu'il faudrait écrire :
i = (int)u.d;
Cela revient à une discussion plus haut. Quand on programme comme une buse, on a des bugs :-).
Dans cette expression, peux tu me dire en quoi le fait que U soit une union intervient ? Ou alors me donner un meilleur exemple de ce que tu disait, je cite :
Je disais juste que les unions sont un excellent exemple de cast sauvage "à la volée".
-- Loïc
Loïc Joly
AMcD® wrote:
Loïc Joly wrote:
In Visual C++ .NET 2002, the new function in the Standard C++ Library will support the behavior specified in the C++ standard, which is to throw a std::bad_alloc exception if the memory allocation fails.
Tiens donc, ça peut échouer un new alors :-) ?
Bien entendu. Depuis le départ, je dis juste que par défaut, quand new échoue, le fonction ne retourne pas, puisqu'une exception est lancée, et que donc tester si la valeur de retour est valide ou non est un échec.
9 [Example: T* p1 = new T; // throws bad_alloc if it fails T* p2 >>>new(nothrow) T; // returns 0 if it fails —end example]
Bah oui, mais 0, j'appelle pas ça un pointeur valide moi. Je te répète ta phrase :
"new ne peut pas retourner autre chose qu'un pointeur valide"
0, c'est pas un pointeur valide.
Où vois tu 0 dans un appel de new classique ?
Je répète l'exemple :
Appel classique de new :
T* p1 = new T; // throws bad_alloc if it fails
Appel spécial de new :
T* p2 = new(nothrow) T; // returns 0 if it fails
A moins de le spécifier explicitement en employant la clause nothrow, new ne retourne pas en cas d'échec.
-- Loïc
AMcD® wrote:
Loïc Joly wrote:
In Visual C++ .NET 2002, the new function in the Standard C++ Library
will support the behavior specified in the C++ standard, which is to
throw a std::bad_alloc exception if the memory allocation fails.
Tiens donc, ça peut échouer un new alors :-) ?
Bien entendu. Depuis le départ, je dis juste que par défaut, quand new
échoue, le fonction ne retourne pas, puisqu'une exception est lancée, et
que donc tester si la valeur de retour est valide ou non est un échec.
9 [Example: T* p1 = new T; // throws bad_alloc if it fails T* p2 >>>new(nothrow) T; // returns 0 if it fails —end example]
Bah oui, mais 0, j'appelle pas ça un pointeur valide moi. Je te répète ta
phrase :
"new ne peut pas retourner autre chose qu'un pointeur valide"
0, c'est pas un pointeur valide.
Où vois tu 0 dans un appel de new classique ?
Je répète l'exemple :
Appel classique de new :
T* p1 = new T; // throws bad_alloc if it fails
Appel spécial de new :
T* p2 = new(nothrow) T; // returns 0 if it fails
A moins de le spécifier explicitement en employant la clause nothrow,
new ne retourne pas en cas d'échec.
In Visual C++ .NET 2002, the new function in the Standard C++ Library will support the behavior specified in the C++ standard, which is to throw a std::bad_alloc exception if the memory allocation fails.
Tiens donc, ça peut échouer un new alors :-) ?
Bien entendu. Depuis le départ, je dis juste que par défaut, quand new échoue, le fonction ne retourne pas, puisqu'une exception est lancée, et que donc tester si la valeur de retour est valide ou non est un échec.
9 [Example: T* p1 = new T; // throws bad_alloc if it fails T* p2 >>>new(nothrow) T; // returns 0 if it fails —end example]
Bah oui, mais 0, j'appelle pas ça un pointeur valide moi. Je te répète ta phrase :
"new ne peut pas retourner autre chose qu'un pointeur valide"
0, c'est pas un pointeur valide.
Où vois tu 0 dans un appel de new classique ?
Je répète l'exemple :
Appel classique de new :
T* p1 = new T; // throws bad_alloc if it fails
Appel spécial de new :
T* p2 = new(nothrow) T; // returns 0 if it fails
A moins de le spécifier explicitement en employant la clause nothrow, new ne retourne pas en cas d'échec.
-- Loïc
AMcD®
Loïc Joly wrote:
Dans cette expression, peux tu me dire en quoi le fait que U soit une union intervient ?
M'ouais, mauvais exemple de ma part
-- AMcD®
http://arnold.mcdonald.free.fr/.
Loïc Joly wrote:
Dans cette expression, peux tu me dire en quoi le fait que U soit une
union intervient ?
Dans cette expression, peux tu me dire en quoi le fait que U soit une union intervient ?
M'ouais, mauvais exemple de ma part
-- AMcD®
http://arnold.mcdonald.free.fr/.
Bertrand Lenoir-Welter
> Je ne pense pas, je connais des gens de la vieille école qui préfèrent choisir l'outil adapté, plutôt que se limiter au seul outil qu'ils connaissent.
Amusant. J'ai écrit que j'utilisais principalement new, mais que le malloc me rendait parfois service dans certains cas. Conclusion : je n'utilise que l'outil que je connais. Il est des raccourcis...
> Je ne pense pas, je connais des gens de la vieille école qui préfèrent
choisir l'outil adapté, plutôt que se limiter au seul outil qu'ils
connaissent.
Amusant. J'ai écrit que j'utilisais principalement new, mais que le
malloc me rendait parfois service dans certains cas. Conclusion : je
n'utilise que l'outil que je connais. Il est des raccourcis...
> Je ne pense pas, je connais des gens de la vieille école qui préfèrent choisir l'outil adapté, plutôt que se limiter au seul outil qu'ils connaissent.
Amusant. J'ai écrit que j'utilisais principalement new, mais que le malloc me rendait parfois service dans certains cas. Conclusion : je n'utilise que l'outil que je connais. Il est des raccourcis...
Vincent Burel
"Alexandre" wrote in message news:4197b504$0$30305$
bonjour,
> C'est une confusion classique chez les "pseudo-programmeur" C++, je le > répète donc, le NEW en C++ sert à hinstancier, créer et déclencher
l'appel
> du constructeur d'un object de type C++. le Malloc est une fonction qui > permet d'allouer de la mémoire. Donc, il n'y a pas grand rapport avec
ces
> deux fonctions, ou plutot fonctionnalités, car "malloc" est une fonction > d'un librairie, "new" est un mot réservé du langage...
merci pour le pseudo-programmeur, un jour je te dirais où je travailles.
si vous voulez, mais sachez que cela ne m'intéresse pas beaucoup. l'emploi du terme "pseudo-programmeur" était surtout un moyen pour moi d'évaluer votre taux d'humour...
new sert effectivement à instancier (pas de h ici, ne pas confondre avec
une
hInstance) un objet, mais également à allouer de la mémoire. Donc comme malloc, mais en mieux (par ex déclenchement d'une exception en cas de pb).
Alors non ! il faut que je le répète encore et encore, (les "pseudo programmeurs" sont sourds , c'est connu) ... new ne sert pas à allouer de la mémoire, la mémoire c'est un composant système gérer par le système, pour allouer de la mémoire il faut donc utiliser les services systèmes, sous windows, ca peut se faire avec les API HeapAlloc, GlobalAlloc etc.. ou bien à l'aide de la fonction généric d'un librairie "C/C++" ; MALLOC qui elle, est définit comme une fonction d'allocation mémoire et qui d'ailleurs fait appel au système pour faire son allocation... New sert à créer un objet ++, si cela engendre une allocation mémoire , c'est fortuit et généralement non désiré, l'utilisateur C++ ne comprend généralement pas qu'un ordinateur ne puisse plus créer d'objet par manque de mémoire. ca lui parait sur-réaliste ! ce qui est vrai, car encore une fois, le new n'est pas là pour allouer de la mémoire. :-)
En ++ par contre on peut créer un objet de type Tallocator par exemple qui lui, va permettre d'allouer de la mémoire, ou de la gérer, à la mode que vous voulez, en stream, en buffer, en stack, en array...
pas confusion. Raccourci. Je ne vais pas tout redétailler à chaque fois. Le conseil intelligent à donner à un débutant, ce n'est pas de faire des malloc pour gérer un tableau dont la taille varie, c'est d'utiliser std::vector. Il va gagner un temps énorme.
Oui, cependant le débutant se doit de se faire un tableau dynamique avec du malloc, il se doit de faire des applications typiques comme celle ci, il se doit d'expérimenter les concept de base de la programmation. Parce que le débutant a du temps par définition ! temps qu'il doit utiliser pour comprendre les mécanismes de bases de l'informatique, ainsi aura-t-il une chance de devenir un programmeur...
VB
"Alexandre" <alex.g@netcourrier.com> wrote in message
news:4197b504$0$30305$626a14ce@news.free.fr...
bonjour,
> C'est une confusion classique chez les "pseudo-programmeur" C++, je le
> répète donc, le NEW en C++ sert à hinstancier, créer et déclencher
l'appel
> du constructeur d'un object de type C++. le Malloc est une fonction qui
> permet d'allouer de la mémoire. Donc, il n'y a pas grand rapport avec
ces
> deux fonctions, ou plutot fonctionnalités, car "malloc" est une fonction
> d'un librairie, "new" est un mot réservé du langage...
merci pour le pseudo-programmeur, un jour je te dirais où je travailles.
si vous voulez, mais sachez que cela ne m'intéresse pas beaucoup. l'emploi
du terme "pseudo-programmeur" était surtout un moyen pour moi d'évaluer
votre taux d'humour...
new sert effectivement à instancier (pas de h ici, ne pas confondre avec
une
hInstance) un objet, mais également à allouer de la mémoire. Donc comme
malloc, mais en mieux (par ex déclenchement d'une exception en cas de pb).
Alors non ! il faut que je le répète encore et encore, (les "pseudo
programmeurs" sont sourds , c'est connu) ... new ne sert pas à allouer de la
mémoire, la mémoire c'est un composant système gérer par le système, pour
allouer de la mémoire il faut donc utiliser les services systèmes, sous
windows, ca peut se faire avec les API HeapAlloc, GlobalAlloc etc.. ou bien
à l'aide de la fonction généric d'un librairie "C/C++" ; MALLOC qui elle,
est définit comme une fonction d'allocation mémoire et qui d'ailleurs fait
appel au système pour faire son allocation... New sert à créer un objet ++,
si cela engendre une allocation mémoire , c'est fortuit et généralement non
désiré, l'utilisateur C++ ne comprend généralement pas qu'un ordinateur ne
puisse plus créer d'objet par manque de mémoire. ca lui parait sur-réaliste
! ce qui est vrai, car encore une fois, le new n'est pas là pour allouer de
la mémoire. :-)
En ++ par contre on peut créer un objet de type Tallocator par exemple qui
lui, va permettre d'allouer de la mémoire, ou de la gérer, à la mode que
vous voulez, en stream, en buffer, en stack, en array...
pas confusion. Raccourci. Je ne vais pas tout redétailler à chaque fois.
Le conseil intelligent à donner à un débutant, ce n'est pas de faire des
malloc pour gérer un tableau dont la taille varie, c'est d'utiliser
std::vector. Il va gagner un temps énorme.
Oui, cependant le débutant se doit de se faire un tableau dynamique avec du
malloc, il se doit de faire des applications typiques comme celle ci, il se
doit d'expérimenter les concept de base de la programmation. Parce que le
débutant a du temps par définition ! temps qu'il doit utiliser pour
comprendre les mécanismes de bases de l'informatique, ainsi aura-t-il une
chance de devenir un programmeur...
"Alexandre" wrote in message news:4197b504$0$30305$
bonjour,
> C'est une confusion classique chez les "pseudo-programmeur" C++, je le > répète donc, le NEW en C++ sert à hinstancier, créer et déclencher
l'appel
> du constructeur d'un object de type C++. le Malloc est une fonction qui > permet d'allouer de la mémoire. Donc, il n'y a pas grand rapport avec
ces
> deux fonctions, ou plutot fonctionnalités, car "malloc" est une fonction > d'un librairie, "new" est un mot réservé du langage...
merci pour le pseudo-programmeur, un jour je te dirais où je travailles.
si vous voulez, mais sachez que cela ne m'intéresse pas beaucoup. l'emploi du terme "pseudo-programmeur" était surtout un moyen pour moi d'évaluer votre taux d'humour...
new sert effectivement à instancier (pas de h ici, ne pas confondre avec
une
hInstance) un objet, mais également à allouer de la mémoire. Donc comme malloc, mais en mieux (par ex déclenchement d'une exception en cas de pb).
Alors non ! il faut que je le répète encore et encore, (les "pseudo programmeurs" sont sourds , c'est connu) ... new ne sert pas à allouer de la mémoire, la mémoire c'est un composant système gérer par le système, pour allouer de la mémoire il faut donc utiliser les services systèmes, sous windows, ca peut se faire avec les API HeapAlloc, GlobalAlloc etc.. ou bien à l'aide de la fonction généric d'un librairie "C/C++" ; MALLOC qui elle, est définit comme une fonction d'allocation mémoire et qui d'ailleurs fait appel au système pour faire son allocation... New sert à créer un objet ++, si cela engendre une allocation mémoire , c'est fortuit et généralement non désiré, l'utilisateur C++ ne comprend généralement pas qu'un ordinateur ne puisse plus créer d'objet par manque de mémoire. ca lui parait sur-réaliste ! ce qui est vrai, car encore une fois, le new n'est pas là pour allouer de la mémoire. :-)
En ++ par contre on peut créer un objet de type Tallocator par exemple qui lui, va permettre d'allouer de la mémoire, ou de la gérer, à la mode que vous voulez, en stream, en buffer, en stack, en array...
pas confusion. Raccourci. Je ne vais pas tout redétailler à chaque fois. Le conseil intelligent à donner à un débutant, ce n'est pas de faire des malloc pour gérer un tableau dont la taille varie, c'est d'utiliser std::vector. Il va gagner un temps énorme.
Oui, cependant le débutant se doit de se faire un tableau dynamique avec du malloc, il se doit de faire des applications typiques comme celle ci, il se doit d'expérimenter les concept de base de la programmation. Parce que le débutant a du temps par définition ! temps qu'il doit utiliser pour comprendre les mécanismes de bases de l'informatique, ainsi aura-t-il une chance de devenir un programmeur...
VB
Pierre Maurette
Loïc Joly a écrit: [...]
Ce n'est pas plus être dogmatique que de dire que int a=1/0; provoquera une erreur, et qu'il ne faut pas l'écrire.
Vous auriez pu prendre un exemple plus consensuel, non ? ;-) -- Pierre
Loïc Joly <loic.actarus.joly@wanadoo.fr> a écrit:
[...]
Ce n'est pas plus être dogmatique que de dire que int a=1/0; provoquera
une erreur, et qu'il ne faut pas l'écrire.
Vous auriez pu prendre un exemple plus consensuel, non ? ;-)
--
Pierre
Ce n'est pas plus être dogmatique que de dire que int a=1/0; provoquera une erreur, et qu'il ne faut pas l'écrire.
Vous auriez pu prendre un exemple plus consensuel, non ? ;-) -- Pierre
Alexandre
> ??? Bah, à peine que je vérifie les valeurs retournées par les fonctions ! Et après ont s'étonne que les programmes plantent... Rien d'étonnant si les 99% des programmeurs raisonnent comme toi.
Dis-moi, et si ton new() plante, puisque tu ne vérifie pas, je suis curieux de savoir comment tu poursuis ton programme...
bien sur qu'on vérifie, mais un capture les exceptions dans un try...catch qui est général et pas ligne à ligne. Par exemple :
try { A = new classe; B = new classe; C = new classe; D = new classe; } catch(std::bad_alloc) { std::cerr<<"nErreur d'allocation mémoire"; throw; }
au lieu de A = (classe*)malloc(sizeof(classe)); if(A==NULL) { std::cerr<<"nErreur d'allocation mémoire"; } else { B= (classe*)malloc(sizeof(classe)); if(B==NULL) std::cerr<<"nErreur d'allocation"; else { C = ...
et ainsi de suite. La 2e version ne te parait pas plus lourde que la première ?
Il n'y a pas de lourdeur dans le sérieux et la rigueur mon ami.
il n'y a pas forcément de sérieur et de rigueur quand on choisit une solution plus lourde qu'une autre ;-)
-- AMcD®
http://arnold.mcdonald.free.fr/
>
??? Bah, à peine que je vérifie les valeurs retournées par les fonctions !
Et après ont s'étonne que les programmes plantent... Rien d'étonnant si
les 99% des programmeurs raisonnent comme toi.
Dis-moi, et si ton new() plante, puisque tu ne vérifie pas, je suis
curieux de savoir comment tu poursuis ton programme...
bien sur qu'on vérifie, mais un capture les exceptions dans un try...catch
qui est général et pas ligne à ligne.
Par exemple :
try {
A = new classe;
B = new classe;
C = new classe;
D = new classe;
}
catch(std::bad_alloc)
{
std::cerr<<"nErreur d'allocation mémoire";
throw;
}
au lieu de
A = (classe*)malloc(sizeof(classe));
if(A==NULL)
{
std::cerr<<"nErreur d'allocation mémoire";
}
else
{
B= (classe*)malloc(sizeof(classe));
if(B==NULL)
std::cerr<<"nErreur d'allocation";
else
{
C = ...
et ainsi de suite. La 2e version ne te parait pas plus lourde que la
première ?
Il n'y a pas de lourdeur dans le sérieux et la rigueur mon ami.
il n'y a pas forcément de sérieur et de rigueur quand on choisit une
solution plus lourde qu'une autre ;-)
> ??? Bah, à peine que je vérifie les valeurs retournées par les fonctions ! Et après ont s'étonne que les programmes plantent... Rien d'étonnant si les 99% des programmeurs raisonnent comme toi.
Dis-moi, et si ton new() plante, puisque tu ne vérifie pas, je suis curieux de savoir comment tu poursuis ton programme...
bien sur qu'on vérifie, mais un capture les exceptions dans un try...catch qui est général et pas ligne à ligne. Par exemple :
try { A = new classe; B = new classe; C = new classe; D = new classe; } catch(std::bad_alloc) { std::cerr<<"nErreur d'allocation mémoire"; throw; }
au lieu de A = (classe*)malloc(sizeof(classe)); if(A==NULL) { std::cerr<<"nErreur d'allocation mémoire"; } else { B= (classe*)malloc(sizeof(classe)); if(B==NULL) std::cerr<<"nErreur d'allocation"; else { C = ...
et ainsi de suite. La 2e version ne te parait pas plus lourde que la première ?
Il n'y a pas de lourdeur dans le sérieux et la rigueur mon ami.
il n'y a pas forcément de sérieur et de rigueur quand on choisit une solution plus lourde qu'une autre ;-)
-- AMcD®
http://arnold.mcdonald.free.fr/
Alexandre
> "Tu vérifies EN PERMANENCE dans ton code le retour de new ? Que c'est lourd !"
c'est ta place que tu joues... Moi, si j'étais patron d'une boîte et qu'un programmeur me sort ça, c'est la remontée de bretelle assurée mon gars ! Au minimum ça te vaudrait que j'aille avec grande inquiètude jeter un oeil dans ton code et vu tes "concepts" philosophiques tu serais vite en position de départ pré-ANPE...
et dans mon cas je préfère que le programmeur se mette à l'abri d'un (très humain) oubli de vérification.
PS : T'inquiète pas, je suis pas patron de société de logiciel :-).
-- AMcD®
http://arnold.mcdonald.free.fr/
>
"Tu vérifies EN PERMANENCE dans ton code le retour de new ? Que c'est
lourd !"
c'est ta place que tu joues... Moi, si j'étais patron d'une boîte et qu'un
programmeur me sort ça, c'est la remontée de bretelle assurée mon gars !
Au minimum ça te vaudrait que j'aille avec grande inquiètude jeter un oeil
dans ton code et vu tes "concepts" philosophiques tu serais vite en
position de départ pré-ANPE...
et dans mon cas je préfère que le programmeur se mette à l'abri d'un (très
humain) oubli de vérification.
PS : T'inquiète pas, je suis pas patron de société de logiciel :-).
> "Tu vérifies EN PERMANENCE dans ton code le retour de new ? Que c'est lourd !"
c'est ta place que tu joues... Moi, si j'étais patron d'une boîte et qu'un programmeur me sort ça, c'est la remontée de bretelle assurée mon gars ! Au minimum ça te vaudrait que j'aille avec grande inquiètude jeter un oeil dans ton code et vu tes "concepts" philosophiques tu serais vite en position de départ pré-ANPE...
et dans mon cas je préfère que le programmeur se mette à l'abri d'un (très humain) oubli de vérification.
PS : T'inquiète pas, je suis pas patron de société de logiciel :-).
-- AMcD®
http://arnold.mcdonald.free.fr/
Alexandre
> Ben c'est tiré de la doc de mon Visual C++.Net 2002
In Visual C++ .NET 2002, the new function in the Standard C++ Library will support the behavior specified in the C++ standard, which is to throw a std::bad_alloc exception if the memory allocation fails.
Tiens donc, ça peut échouer un new alors :-) ?
oui, mais comme Loic Joly l'a indiqué, la valeur renvoyée par new est *toujours* valide, puisque s'il échoue, il lève une exception et donc ne renvoie rien... C'est l'interet. Donc c'est inutile, chronophage de vérifier sa valeur qui ne sera *jamais* NULL, sauf sur les vieux compilos qui ne respectent pas la norme C++
9 [Example: T* p1 = new T; // throws bad_alloc if it fails T* p2 >>> new(nothrow) T; // returns 0 if it fails -end example]
Bah oui, mais 0, j'appelle pas ça un pointeur valide moi. Je te répète ta phrase :
"new ne peut pas retourner autre chose qu'un pointeur valide"
0, c'est pas un pointeur valide.
-- AMcD®
http://arnold.mcdonald.free.fr/
> Ben c'est tiré de la doc de mon Visual C++.Net 2002
In Visual C++ .NET 2002, the new function in the Standard C++ Library
will support the behavior specified in the C++ standard, which is to
throw a std::bad_alloc exception if the memory allocation fails.
Tiens donc, ça peut échouer un new alors :-) ?
oui, mais comme Loic Joly l'a indiqué, la valeur renvoyée par new est
*toujours* valide, puisque s'il échoue, il lève une exception et donc ne
renvoie rien... C'est l'interet. Donc c'est inutile, chronophage de vérifier
sa valeur qui ne sera *jamais* NULL, sauf sur les vieux compilos qui ne
respectent pas la norme C++
9 [Example: T* p1 = new T; // throws bad_alloc if it fails T* p2 >>> new(nothrow) T; // returns 0 if it fails -end example]
Bah oui, mais 0, j'appelle pas ça un pointeur valide moi. Je te répète ta
phrase :
"new ne peut pas retourner autre chose qu'un pointeur valide"
> Ben c'est tiré de la doc de mon Visual C++.Net 2002
In Visual C++ .NET 2002, the new function in the Standard C++ Library will support the behavior specified in the C++ standard, which is to throw a std::bad_alloc exception if the memory allocation fails.
Tiens donc, ça peut échouer un new alors :-) ?
oui, mais comme Loic Joly l'a indiqué, la valeur renvoyée par new est *toujours* valide, puisque s'il échoue, il lève une exception et donc ne renvoie rien... C'est l'interet. Donc c'est inutile, chronophage de vérifier sa valeur qui ne sera *jamais* NULL, sauf sur les vieux compilos qui ne respectent pas la norme C++
9 [Example: T* p1 = new T; // throws bad_alloc if it fails T* p2 >>> new(nothrow) T; // returns 0 if it fails -end example]
Bah oui, mais 0, j'appelle pas ça un pointeur valide moi. Je te répète ta phrase :
"new ne peut pas retourner autre chose qu'un pointeur valide"
