Au contraire. Le cast explicit supprime la vérification du type.
La quelle?
Sans cast explicite, on detecte l'erreur d'avoir un malloc declare implicitement.
Ce n'est pas une erreur requérant un 'diagnostic'. Donc, si le reglage du compilateur est laxiste, on ne verra rien du tout. Je rappelle que les warnings font partie de la QoI (Quality of Implementation) et n'ont aucun caractère obligatoire.
Avec un cast explicite, on detecte l'erreur d'avoir modifie le type de la variable sans avoir modifie l'allocation (je rappelle que je conseillais une macro pour que le type du cast soit bien celui du sizeof).
La méthode idiomatique
type *p = malloc(sizeof *p)
ou
type *p = malloc(sizeof *p * n);
évite tout ces problèmes de types sans intérêt...
-- Emmanuel The C-FAQ: http://www.eskimo.com/~scs/C-faq/faq.html
"C is a sharp tool"
Jean-Marc Bourguet wrote on 03/08/04 :
Au contraire. Le cast explicit supprime la vérification du type.
La quelle?
Sans cast explicite, on detecte l'erreur d'avoir un malloc declare
implicitement.
Ce n'est pas une erreur requérant un 'diagnostic'. Donc, si le reglage
du compilateur est laxiste, on ne verra rien du tout. Je rappelle que
les warnings font partie de la QoI (Quality of Implementation) et n'ont
aucun caractère obligatoire.
Avec un cast explicite, on detecte l'erreur d'avoir modifie le type de
la variable sans avoir modifie l'allocation (je rappelle que je
conseillais une macro pour que le type du cast soit bien celui du
sizeof).
La méthode idiomatique
type *p = malloc(sizeof *p)
ou
type *p = malloc(sizeof *p * n);
évite tout ces problèmes de types sans intérêt...
--
Emmanuel
The C-FAQ: http://www.eskimo.com/~scs/C-faq/faq.html
Au contraire. Le cast explicit supprime la vérification du type.
La quelle?
Sans cast explicite, on detecte l'erreur d'avoir un malloc declare implicitement.
Ce n'est pas une erreur requérant un 'diagnostic'. Donc, si le reglage du compilateur est laxiste, on ne verra rien du tout. Je rappelle que les warnings font partie de la QoI (Quality of Implementation) et n'ont aucun caractère obligatoire.
Avec un cast explicite, on detecte l'erreur d'avoir modifie le type de la variable sans avoir modifie l'allocation (je rappelle que je conseillais une macro pour que le type du cast soit bien celui du sizeof).
La méthode idiomatique
type *p = malloc(sizeof *p)
ou
type *p = malloc(sizeof *p * n);
évite tout ces problèmes de types sans intérêt...
-- Emmanuel The C-FAQ: http://www.eskimo.com/~scs/C-faq/faq.html
"C is a sharp tool"
Horst Kraemer
Jean-Marc Bourguet wrote:
Au contraire. Le cast explicit supprime la vérification du type.
La quelle?
Sans cast explicite, on detecte l'erreur d'avoir un malloc declare implicitement.
Avec un cast explicite, on detecte l'erreur d'avoir modifie le type de la variable sans avoir modifie l'allocation (je rappelle que je conseillais une macro pour que le type du cast soit bien celui du sizeof).
Tu veux dire qu'ici
int * p;
p = (char*)malloc(42);
le cast "détecte" l'erreur que le programmeur croit que le type de p est (char*) tandis que le type de p est (int*) ?
Mais a-t-il vraiment un sens d'injecter de temps en temps un cast inutile pour vérifier si on se rappelle encore le type de son pointeur? ;-)
-- Horst
-- Lâche pas la patate!
Jean-Marc Bourguet <jm@bourguet.org> wrote:
Au contraire. Le cast explicit supprime la vérification du type.
La quelle?
Sans cast explicite, on detecte l'erreur d'avoir un malloc declare
implicitement.
Avec un cast explicite, on detecte l'erreur d'avoir modifie le type de
la variable sans avoir modifie l'allocation (je rappelle que je
conseillais une macro pour que le type du cast soit bien celui du
sizeof).
Tu veux dire qu'ici
int * p;
p = (char*)malloc(42);
le cast "détecte" l'erreur que le programmeur croit que le type de p
est (char*) tandis que le type de p est (int*) ?
Mais a-t-il vraiment un sens d'injecter de temps en temps un cast
inutile pour vérifier si on se rappelle encore le type de son
pointeur? ;-)
Au contraire. Le cast explicit supprime la vérification du type.
La quelle?
Sans cast explicite, on detecte l'erreur d'avoir un malloc declare implicitement.
Avec un cast explicite, on detecte l'erreur d'avoir modifie le type de la variable sans avoir modifie l'allocation (je rappelle que je conseillais une macro pour que le type du cast soit bien celui du sizeof).
Tu veux dire qu'ici
int * p;
p = (char*)malloc(42);
le cast "détecte" l'erreur que le programmeur croit que le type de p est (char*) tandis que le type de p est (int*) ?
Mais a-t-il vraiment un sens d'injecter de temps en temps un cast inutile pour vérifier si on se rappelle encore le type de son pointeur? ;-)
-- Horst
-- Lâche pas la patate!
Jean-Marc Bourguet
Horst Kraemer writes:
Jean-Marc Bourguet wrote: [...]
Tu veux dire qu'ici
int * p;
p = (char*)malloc(42);
le cast "détecte" l'erreur que le programmeur croit que le type de p est (char*) tandis que le type de p est (int*) ?
Mais a-t-il vraiment un sens d'injecter de temps en temps un cast inutile pour vérifier si on se rappelle encore le type de son pointeur? ;-)
Le probleme est evidemment a la maintenance. Dans ce que je fais, il y a dizaines de millions de lignes de code existantes. On passe beaucoup plus de temps a modifier qu'a ecrire de nouveaux fichiers.
A+
-- Jean-Marc FAQ de fclc: http://www.isty-info.uvsq.fr/~rumeau/fclc Site de usenet-fr: http://www.usenet-fr.news.eu.org
Horst Kraemer <horst.kraemer@epost.de> writes:
Jean-Marc Bourguet <jm@bourguet.org> wrote:
[...]
Tu veux dire qu'ici
int * p;
p = (char*)malloc(42);
le cast "détecte" l'erreur que le programmeur croit que le type de p
est (char*) tandis que le type de p est (int*) ?
Mais a-t-il vraiment un sens d'injecter de temps en temps un cast
inutile pour vérifier si on se rappelle encore le type de son
pointeur? ;-)
Le probleme est evidemment a la maintenance. Dans ce que je fais, il
y a dizaines de millions de lignes de code existantes. On passe
beaucoup plus de temps a modifier qu'a ecrire de nouveaux fichiers.
A+
--
Jean-Marc
FAQ de fclc: http://www.isty-info.uvsq.fr/~rumeau/fclc
Site de usenet-fr: http://www.usenet-fr.news.eu.org
le cast "détecte" l'erreur que le programmeur croit que le type de p est (char*) tandis que le type de p est (int*) ?
Mais a-t-il vraiment un sens d'injecter de temps en temps un cast inutile pour vérifier si on se rappelle encore le type de son pointeur? ;-)
Le probleme est evidemment a la maintenance. Dans ce que je fais, il y a dizaines de millions de lignes de code existantes. On passe beaucoup plus de temps a modifier qu'a ecrire de nouveaux fichiers.
A+
-- Jean-Marc FAQ de fclc: http://www.isty-info.uvsq.fr/~rumeau/fclc Site de usenet-fr: http://www.usenet-fr.news.eu.org
Jean-Marc Bourguet
Emmanuel Delahaye writes:
La méthode idiomatique [...]
J'ai vu utiliser trop de manieres differentes pour penser qu'une d'elle soit idiomatique. Note que je citais aussi ta methode dans la suite.
A+
-- Jean-Marc FAQ de fclc: http://www.isty-info.uvsq.fr/~rumeau/fclc Site de usenet-fr: http://www.usenet-fr.news.eu.org
Emmanuel Delahaye <emdel@YOURBRAnoos.fr> writes:
La méthode idiomatique
[...]
J'ai vu utiliser trop de manieres differentes pour penser qu'une
d'elle soit idiomatique. Note que je citais aussi ta methode dans la
suite.
A+
--
Jean-Marc
FAQ de fclc: http://www.isty-info.uvsq.fr/~rumeau/fclc
Site de usenet-fr: http://www.usenet-fr.news.eu.org
J'ai vu utiliser trop de manieres differentes pour penser qu'une d'elle soit idiomatique. Note que je citais aussi ta methode dans la suite.
A+
-- Jean-Marc FAQ de fclc: http://www.isty-info.uvsq.fr/~rumeau/fclc Site de usenet-fr: http://www.usenet-fr.news.eu.org
James Kanze
Horst Kraemer writes:
|> Jean-Marc Bourguet wrote:
|> > > Au contraire. Le cast explicit supprime la vérification du type.
|> > La quelle?
|> > Sans cast explicite, on detecte l'erreur d'avoir un malloc declare |> > implicitement.
|> > Avec un cast explicite, on detecte l'erreur d'avoir modifie le type de |> > la variable sans avoir modifie l'allocation (je rappelle que je |> > conseillais une macro pour que le type du cast soit bien celui du |> > sizeof).
|> Tu veux dire qu'ici
|> int * p;
|> p = (char*)malloc(42);
|> le cast "détecte" l'erreur que le programmeur croit que le type de p |> est (char*) tandis que le type de p est (int*) ?
Je crois qu'il veut dire que le cast fait taire le compilateur même si le programmeur a oublié d'inclure l'en-tête nécessaire, et qu'en ce qui concerne le type de retour de malloc, c'est un int implicit.
-- James Kanze Conseils en informatique orientée objet/ Beratung in objektorientierter Datenverarbeitung 9 place Sémard, 78210 St.-Cyr-l'École, France +33 (0)1 30 23 00 34
Horst Kraemer <horst.kraemer@epost.de> writes:
|> Jean-Marc Bourguet <jm@bourguet.org> wrote:
|> > > Au contraire. Le cast explicit supprime la vérification du type.
|> > La quelle?
|> > Sans cast explicite, on detecte l'erreur d'avoir un malloc declare
|> > implicitement.
|> > Avec un cast explicite, on detecte l'erreur d'avoir modifie le type de
|> > la variable sans avoir modifie l'allocation (je rappelle que je
|> > conseillais une macro pour que le type du cast soit bien celui du
|> > sizeof).
|> Tu veux dire qu'ici
|> int * p;
|> p = (char*)malloc(42);
|> le cast "détecte" l'erreur que le programmeur croit que le type de p
|> est (char*) tandis que le type de p est (int*) ?
Je crois qu'il veut dire que le cast fait taire le compilateur même si
le programmeur a oublié d'inclure l'en-tête nécessaire, et qu'en ce qui
concerne le type de retour de malloc, c'est un int implicit.
--
James Kanze
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France +33 (0)1 30 23 00 34
|> > > Au contraire. Le cast explicit supprime la vérification du type.
|> > La quelle?
|> > Sans cast explicite, on detecte l'erreur d'avoir un malloc declare |> > implicitement.
|> > Avec un cast explicite, on detecte l'erreur d'avoir modifie le type de |> > la variable sans avoir modifie l'allocation (je rappelle que je |> > conseillais une macro pour que le type du cast soit bien celui du |> > sizeof).
|> Tu veux dire qu'ici
|> int * p;
|> p = (char*)malloc(42);
|> le cast "détecte" l'erreur que le programmeur croit que le type de p |> est (char*) tandis que le type de p est (int*) ?
Je crois qu'il veut dire que le cast fait taire le compilateur même si le programmeur a oublié d'inclure l'en-tête nécessaire, et qu'en ce qui concerne le type de retour de malloc, c'est un int implicit.
-- James Kanze Conseils en informatique orientée objet/ Beratung in objektorientierter Datenverarbeitung 9 place Sémard, 78210 St.-Cyr-l'École, France +33 (0)1 30 23 00 34
