Depuis quelques temps, j'ai pris l'habitude d'écrire
mes malloc sous la forme
p= malloc( sizeof(*p) );
ce qui a le bon cote de ne pas me forcer à me souvenir
du nom du type de *p.
Mais, souvent, mon p vaut NULL, l'expression
sizeof(*p)
reviens donc à déreférencer un pointeur NULL.
Ca a toujours marché avec mes compilos, mais est-ce
une pratique recommandable ?
Marc Boyer
--
La contractualisation de la recherche, c'est me donner de l'argent pour
faire ce que je ne sais pas faire, que je fais donc mal, pendant que ce
que je sais faire, je le fais sans moyens...
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
DINH Viêt Hoà
Mais, souvent, mon p vaut NULL, l'expression sizeof(*p) reviens donc à déreférencer un pointeur NULL.
pas du tout, puisque le calcul se fait à la compilation et non à l'exécution. Il te donne la taille du type pointé par p. Il faut bien entendu que le pointeur utilisé pour p soit typé. Il faut voir sizeof comme un opérateur et non comme une fonction, même si j'écris le sizeof également à la façon d'une fonction.
Ca a toujours marché avec mes compilos, mais est-ce une pratique recommandable ?
oui.
D'ailleurs, je dirai plutôt que cela sert à ne pas avoir à changer beaucoup de code lorsqu'on change de type de données.
-- DINH V. Hoa,
"un bon ingénieur n'est pas paresseux" -- ArSuniK [1]
Mais, souvent, mon p vaut NULL, l'expression
sizeof(*p)
reviens donc à déreférencer un pointeur NULL.
pas du tout, puisque le calcul se fait à la compilation et non à
l'exécution. Il te donne la taille du type pointé par p.
Il faut bien entendu que le pointeur utilisé pour p soit typé.
Il faut voir sizeof comme un opérateur et non comme une fonction,
même si j'écris le sizeof également à la façon d'une fonction.
Ca a toujours marché avec mes compilos, mais est-ce
une pratique recommandable ?
oui.
D'ailleurs, je dirai plutôt que cela sert à ne pas avoir à changer
beaucoup de code lorsqu'on change de type de données.
--
DINH V. Hoa,
"un bon ingénieur n'est pas paresseux" -- ArSuniK [1]
Mais, souvent, mon p vaut NULL, l'expression sizeof(*p) reviens donc à déreférencer un pointeur NULL.
pas du tout, puisque le calcul se fait à la compilation et non à l'exécution. Il te donne la taille du type pointé par p. Il faut bien entendu que le pointeur utilisé pour p soit typé. Il faut voir sizeof comme un opérateur et non comme une fonction, même si j'écris le sizeof également à la façon d'une fonction.
Ca a toujours marché avec mes compilos, mais est-ce une pratique recommandable ?
oui.
D'ailleurs, je dirai plutôt que cela sert à ne pas avoir à changer beaucoup de code lorsqu'on change de type de données.
-- DINH V. Hoa,
"un bon ingénieur n'est pas paresseux" -- ArSuniK [1]
Jean-Marc Bourguet
Marc Boyer writes:
Depuis quelques temps, j'ai pris l'habitude d'écrire mes malloc sous la forme p= malloc( sizeof(*p) ); ce qui a le bon cote de ne pas me forcer à me souvenir du nom du type de *p.
Mais, souvent, mon p vaut NULL, l'expression sizeof(*p) reviens donc à déreférencer un pointeur NULL. Ca a toujours marché avec mes compilos, mais est-ce une pratique recommandable ?
Ca ne pose aucun probleme, l'expression n'est pas evaluee, seul son type est considere.
Imagine:
char t[sizeof(*p)];
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
Marc Boyer <Marc.Boyer@enseeiht.yahoo.fr.invalid> writes:
Depuis quelques temps, j'ai pris l'habitude d'écrire
mes malloc sous la forme
p= malloc( sizeof(*p) );
ce qui a le bon cote de ne pas me forcer à me souvenir
du nom du type de *p.
Mais, souvent, mon p vaut NULL, l'expression
sizeof(*p)
reviens donc à déreférencer un pointeur NULL.
Ca a toujours marché avec mes compilos, mais est-ce
une pratique recommandable ?
Ca ne pose aucun probleme, l'expression n'est pas evaluee, seul son
type est considere.
Imagine:
char t[sizeof(*p)];
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
Depuis quelques temps, j'ai pris l'habitude d'écrire mes malloc sous la forme p= malloc( sizeof(*p) ); ce qui a le bon cote de ne pas me forcer à me souvenir du nom du type de *p.
Mais, souvent, mon p vaut NULL, l'expression sizeof(*p) reviens donc à déreférencer un pointeur NULL. Ca a toujours marché avec mes compilos, mais est-ce une pratique recommandable ?
Ca ne pose aucun probleme, l'expression n'est pas evaluee, seul son type est considere.
Imagine:
char t[sizeof(*p)];
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
Marc Boyer
Jean-Marc Bourguet wrote:
Marc Boyer writes: char t[sizeof(*p)];
Et oui, c'est résolu à la compilation, donc sans prendre la valeur en compte...
On se pose de ses questions quand on prépare un cours...
Merci,
Marc Boyer -- La contractualisation de la recherche, c'est me donner de l'argent pour faire ce que je ne sais pas faire, que je fais donc mal, pendant que ce que je sais faire, je le fais sans moyens...
Jean-Marc Bourguet wrote:
Marc Boyer <Marc.Boyer@enseeiht.yahoo.fr.invalid> writes:
char t[sizeof(*p)];
Et oui, c'est résolu à la compilation, donc sans prendre
la valeur en compte...
On se pose de ses questions quand on prépare un cours...
Merci,
Marc Boyer
--
La contractualisation de la recherche, c'est me donner de l'argent pour
faire ce que je ne sais pas faire, que je fais donc mal, pendant que ce
que je sais faire, je le fais sans moyens...
Et oui, c'est résolu à la compilation, donc sans prendre la valeur en compte...
On se pose de ses questions quand on prépare un cours...
Merci,
Marc Boyer -- La contractualisation de la recherche, c'est me donner de l'argent pour faire ce que je ne sais pas faire, que je fais donc mal, pendant que ce que je sais faire, je le fais sans moyens...
Jean-Marc Bourguet
Marc Boyer writes:
On se pose de ses questions quand on prépare un cours...
Il vaut mieux se les poser quand on prépare le cours que d'etre pris au depourvu quand un eleve qui les pose (c'est alors qu'on risque de cafouiller).
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
Marc Boyer <Marc.Boyer@enseeiht.yahoo.fr.invalid> writes:
On se pose de ses questions quand on prépare un cours...
Il vaut mieux se les poser quand on prépare le cours que d'etre pris
au depourvu quand un eleve qui les pose (c'est alors qu'on risque de
cafouiller).
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
On se pose de ses questions quand on prépare un cours...
Il vaut mieux se les poser quand on prépare le cours que d'etre pris au depourvu quand un eleve qui les pose (c'est alors qu'on risque de cafouiller).
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
Marc Boyer
Jean-Marc Bourguet wrote:
Marc Boyer writes:
On se pose de ses questions quand on prépare un cours...
Il vaut mieux se les poser quand on prépare le cours que d'etre pris au depourvu quand un eleve qui les pose (c'est alors qu'on risque de cafouiller).
Je me permets toujours de dire "je ne sais pas", suivit de "je me renseignerais d'ici la prochain cours" ou, si ça m'intéresse pas vraiment "si ça vous intéresse, on voit ça après le cours" (devoir rester 15mn de plus avec le prof me semble une évaluation de l'intérêt posé à la question).
Marc Boyer -- La contractualisation de la recherche, c'est me donner de l'argent pour faire ce que je ne sais pas faire, que je fais donc mal, pendant que ce que je sais faire, je le fais sans moyens...
Jean-Marc Bourguet wrote:
Marc Boyer <Marc.Boyer@enseeiht.yahoo.fr.invalid> writes:
On se pose de ses questions quand on prépare un cours...
Il vaut mieux se les poser quand on prépare le cours que d'etre pris
au depourvu quand un eleve qui les pose (c'est alors qu'on risque de
cafouiller).
Je me permets toujours de dire "je ne sais pas", suivit de
"je me renseignerais d'ici la prochain cours" ou, si ça
m'intéresse pas vraiment "si ça vous intéresse, on voit ça
après le cours" (devoir rester 15mn de plus avec le prof
me semble une évaluation de l'intérêt posé à la question).
Marc Boyer
--
La contractualisation de la recherche, c'est me donner de l'argent pour
faire ce que je ne sais pas faire, que je fais donc mal, pendant que ce
que je sais faire, je le fais sans moyens...
On se pose de ses questions quand on prépare un cours...
Il vaut mieux se les poser quand on prépare le cours que d'etre pris au depourvu quand un eleve qui les pose (c'est alors qu'on risque de cafouiller).
Je me permets toujours de dire "je ne sais pas", suivit de "je me renseignerais d'ici la prochain cours" ou, si ça m'intéresse pas vraiment "si ça vous intéresse, on voit ça après le cours" (devoir rester 15mn de plus avec le prof me semble une évaluation de l'intérêt posé à la question).
Marc Boyer -- La contractualisation de la recherche, c'est me donner de l'argent pour faire ce que je ne sais pas faire, que je fais donc mal, pendant que ce que je sais faire, je le fais sans moyens...
Marc Boyer
DINH Viêt Hoà wrote:
Mais, souvent, mon p vaut NULL, l'expression sizeof(*p) reviens donc à déreférencer un pointeur NULL.
pas du tout, puisque le calcul se fait à la compilation et non à l'exécution.
Voui, bien sur, j'aurais du faire le lien...
Il te donne la taille du type pointé par p.
Ce qui est ce que je lui demande, chouette ;-)
Il faut voir sizeof comme un opérateur et non comme une fonction, même si j'écris le sizeof également à la façon d'une fonction.
Ben, oui, mais en C, il existe des opérateurs qui évaluent leurs arguments (&& et ses copains), voir avec des effets de bord ( = ).
D'ailleurs, je dirai plutôt que cela sert à ne pas avoir à changer beaucoup de code lorsqu'on change de type de données.
C'est ce que j'apprécie en effet. Puis l'aspect pédagogique, c'est d'éviter de s'emmeller avec les niveaux d'indirection (quand un arbre est un pointeur sur noeud et qu'on écrit la fonction clone, entre les malloc(Noeud), malloc(*Noeud), malloc(Arbre), malloc(*Arbre), le choix est plus souvent guidé par essai/échec que par la réfléxion).
Marc Boyer -- La contractualisation de la recherche, c'est me donner de l'argent pour faire ce que je ne sais pas faire, que je fais donc mal, pendant que ce que je sais faire, je le fais sans moyens...
DINH Viêt Hoà wrote:
Mais, souvent, mon p vaut NULL, l'expression
sizeof(*p)
reviens donc à déreférencer un pointeur NULL.
pas du tout, puisque le calcul se fait à la compilation et non à
l'exécution.
Voui, bien sur, j'aurais du faire le lien...
Il te donne la taille du type pointé par p.
Ce qui est ce que je lui demande, chouette ;-)
Il faut voir sizeof comme un opérateur et non comme une fonction,
même si j'écris le sizeof également à la façon d'une fonction.
Ben, oui, mais en C, il existe des opérateurs qui évaluent
leurs arguments (&& et ses copains), voir avec des effets
de bord ( = ).
D'ailleurs, je dirai plutôt que cela sert à ne pas avoir à changer
beaucoup de code lorsqu'on change de type de données.
C'est ce que j'apprécie en effet.
Puis l'aspect pédagogique, c'est d'éviter de s'emmeller
avec les niveaux d'indirection (quand un arbre est un pointeur
sur noeud et qu'on écrit la fonction clone, entre les
malloc(Noeud), malloc(*Noeud), malloc(Arbre), malloc(*Arbre),
le choix est plus souvent guidé par essai/échec que par
la réfléxion).
Marc Boyer
--
La contractualisation de la recherche, c'est me donner de l'argent pour
faire ce que je ne sais pas faire, que je fais donc mal, pendant que ce
que je sais faire, je le fais sans moyens...
Mais, souvent, mon p vaut NULL, l'expression sizeof(*p) reviens donc à déreférencer un pointeur NULL.
pas du tout, puisque le calcul se fait à la compilation et non à l'exécution.
Voui, bien sur, j'aurais du faire le lien...
Il te donne la taille du type pointé par p.
Ce qui est ce que je lui demande, chouette ;-)
Il faut voir sizeof comme un opérateur et non comme une fonction, même si j'écris le sizeof également à la façon d'une fonction.
Ben, oui, mais en C, il existe des opérateurs qui évaluent leurs arguments (&& et ses copains), voir avec des effets de bord ( = ).
D'ailleurs, je dirai plutôt que cela sert à ne pas avoir à changer beaucoup de code lorsqu'on change de type de données.
C'est ce que j'apprécie en effet. Puis l'aspect pédagogique, c'est d'éviter de s'emmeller avec les niveaux d'indirection (quand un arbre est un pointeur sur noeud et qu'on écrit la fonction clone, entre les malloc(Noeud), malloc(*Noeud), malloc(Arbre), malloc(*Arbre), le choix est plus souvent guidé par essai/échec que par la réfléxion).
Marc Boyer -- La contractualisation de la recherche, c'est me donner de l'argent pour faire ce que je ne sais pas faire, que je fais donc mal, pendant que ce que je sais faire, je le fais sans moyens...
Horst Kraemer
On 15 Apr 2004 08:59:26 GMT, Marc Boyer wrote:
Depuis quelques temps, j'ai pris l'habitude d'écrire mes malloc sous la forme p= malloc( sizeof(*p) ); ce qui a le bon cote de ne pas me forcer à me souvenir du nom du type de *p.
Mais, souvent, mon p vaut NULL, l'expression sizeof(*p) reviens donc à déreférencer un pointeur NULL.
Non. l'opérateur sizeof n'évalue *pas* son opérande. Il ne donne que le type de l'expression.
p.ex.
int i = 1;
int j;
j = sizeof ++i;
/* ici i vaut toujours 1. */
-- Horst
On 15 Apr 2004 08:59:26 GMT, Marc Boyer
<Marc.Boyer@enseeiht.yahoo.fr.invalid> wrote:
Depuis quelques temps, j'ai pris l'habitude d'écrire
mes malloc sous la forme
p= malloc( sizeof(*p) );
ce qui a le bon cote de ne pas me forcer à me souvenir
du nom du type de *p.
Mais, souvent, mon p vaut NULL, l'expression
sizeof(*p)
reviens donc à déreférencer un pointeur NULL.
Non. l'opérateur sizeof n'évalue *pas* son opérande. Il ne donne que
le type de l'expression.
Depuis quelques temps, j'ai pris l'habitude d'écrire mes malloc sous la forme p= malloc( sizeof(*p) ); ce qui a le bon cote de ne pas me forcer à me souvenir du nom du type de *p.
Mais, souvent, mon p vaut NULL, l'expression sizeof(*p) reviens donc à déreférencer un pointeur NULL.
Non. l'opérateur sizeof n'évalue *pas* son opérande. Il ne donne que le type de l'expression.
p.ex.
int i = 1;
int j;
j = sizeof ++i;
/* ici i vaut toujours 1. */
-- Horst
Emmanuel Delahaye
In 'fr.comp.lang.c', Marc Boyer wrote:
Depuis quelques temps, j'ai pris l'habitude d'écrire mes malloc sous la forme p= malloc( sizeof(*p) );
Bien.
ce qui a le bon cote de ne pas me forcer à me souvenir du nom du type de *p.
Mais, souvent, mon p vaut NULL, l'expression sizeof(*p) reviens donc à déreférencer un pointeur NULL.
On ne déréférence rien du tout. sizeof *p est une constante connue à la compilation. Ce sujet a été épuisé ad nauseam...
-- -ed- [remove YOURBRA before answering me] The C-language FAQ: http://www.eskimo.com/~scs/C-faq/top.html C-reference: http://www.dinkumware.com/manuals/reader.aspx?lib=cpp FAQ de f.c.l.c : http://www.isty-info.uvsq.fr/~rumeau/fclc/
In 'fr.comp.lang.c', Marc Boyer <Marc.Boyer@enseeiht.yahoo.fr.invalid> wrote:
Depuis quelques temps, j'ai pris l'habitude d'écrire
mes malloc sous la forme
p= malloc( sizeof(*p) );
Bien.
ce qui a le bon cote de ne pas me forcer à me souvenir
du nom du type de *p.
Mais, souvent, mon p vaut NULL, l'expression
sizeof(*p)
reviens donc à déreférencer un pointeur NULL.
On ne déréférence rien du tout. sizeof *p est une constante connue à la
compilation. Ce sujet a été épuisé ad nauseam...
--
-ed- emdelYOURBRA@noos.fr [remove YOURBRA before answering me]
The C-language FAQ: http://www.eskimo.com/~scs/C-faq/top.html
C-reference: http://www.dinkumware.com/manuals/reader.aspx?lib=cpp
FAQ de f.c.l.c : http://www.isty-info.uvsq.fr/~rumeau/fclc/
