In 'fr.comp.lang.c', "Patrick "Zener" BRUNET" <http://zener131.free.fr/ContactMe> wrote:
Donc typiquement, si T est un type,
#define N 666 T * pT; int i;
pT = (T *) malloc( N * sizeof( T));
Ce cast n'est pas nécessaire. AMA, il ne fait qu'ajouter à la confusion.
Qu'est-ce qui ne va pas avec:
T *pT = malloc (N * sizeof *pT);
-- -ed- [remove YOURBRA before answering me] The C-language FAQ: http://www.eskimo.com/~scs/C-faq/top.html <blank line> FAQ de f.c.l.c : http://www.isty-info.uvsq.fr/~rumeau/fclc/
Emmanuel Delahaye
In 'fr.comp.lang.c', Jseb wrote:
En résumé, l'astuce consiste à déclarer un tableau de pointeurs void, qui eux ont une taille. Je le déclare ainsi: void *result[N]; et je l'utilise comme suit: result[i]
Oui. Mais ce n'est pas une astuce. C'est la transcription directe de ton besoin.
Pour pouvoir fixer dynamiquement la taille de mon tableau, je pourrais utiliser un pointeur de pointeurs void (void **result), que je pourrais également adresser ainsi: &result[i] (après avoir alloué de la mémoire pour result)
Non. La manière d'adresser un élément de tableau est la même partout :
tableau[indice]
Avec un pointeur correctement initialisé on fait
*(pointeur + indice)
ce qui peut aussi s'écrire
pointeur[indice]
ce qui est très similaire, voire parfaitement identique. La différence (invisible à l'oeil nu) est que 'tableau' est une constante et que 'pointeur' est une variable. Attention par contre au comportement de sizeof qui lui est très différent. Un tableau 'contient' sa taille, un pointeur non (je parle de la taille de l'objet pointé bien sûr).
malloc() retourne un pointeur void * précisément pour ça : l'adresse retournée est : - correctement alignée pour n'importe quel type,
Ca par contre, je comprend pas. L'adresse est de toute façon unique, que l'on adresse ensuite des octets, des words , des quad...
Non. Sur certaines architectures, il est impossible d'adresser un int sur une adresse impaire.
Ca va être une adresse de la taille du bus, c'est tout, non?
Peut être, peut importe...
C'est pour ça que j'ai jamais compris pourquoi on récupèrait un type void,
On récupère un type 'void *', c'est à dire un pointeur sur objet 'universel' non typé justement (mais correctement aligné pour n'importe quel type de donnée).
et qu'il ne fallait pas caster le retour de malloc.
Ce n'est pas qu'il ne /faut/ pas, mais plutôt que c'est inutile de nos jours (cette pratique horrible vient du fond des ages pré-ANSI, donc avant 1989). Bref, on est plus au moyen-age...
Dans la FAQ, tu trouveras d'autres arguments...
-- -ed- [remove YOURBRA before answering me] The C-language FAQ: http://www.eskimo.com/~scs/C-faq/top.html <blank line> FAQ de f.c.l.c : http://www.isty-info.uvsq.fr/~rumeau/fclc/
In 'fr.comp.lang.c', Jseb <jseb@alussinan.org> wrote:
En résumé, l'astuce consiste à déclarer un tableau de pointeurs void,
qui eux ont une taille. Je le déclare ainsi: void *result[N]; et je
l'utilise comme suit: result[i]
Oui. Mais ce n'est pas une astuce. C'est la transcription directe de ton
besoin.
Pour pouvoir fixer dynamiquement la taille de mon tableau, je pourrais
utiliser un pointeur de pointeurs void (void **result), que je
pourrais également adresser ainsi: &result[i] (après avoir alloué de
la mémoire pour result)
Non. La manière d'adresser un élément de tableau est la même partout :
tableau[indice]
Avec un pointeur correctement initialisé on fait
*(pointeur + indice)
ce qui peut aussi s'écrire
pointeur[indice]
ce qui est très similaire, voire parfaitement identique. La différence
(invisible à l'oeil nu) est que 'tableau' est une constante et que 'pointeur'
est une variable. Attention par contre au comportement de sizeof qui lui est
très différent. Un tableau 'contient' sa taille, un pointeur non (je parle
de la taille de l'objet pointé bien sûr).
malloc() retourne un pointeur void * précisément pour ça : l'adresse
retournée est :
- correctement alignée pour n'importe quel type,
Ca par contre, je comprend pas. L'adresse est de toute façon unique,
que l'on adresse ensuite des octets, des words , des quad...
Non. Sur certaines architectures, il est impossible d'adresser un int sur une
adresse impaire.
Ca va être une adresse de la taille du bus, c'est tout, non?
Peut être, peut importe...
C'est pour ça que j'ai jamais compris pourquoi on récupèrait un type
void,
On récupère un type 'void *', c'est à dire un pointeur sur objet 'universel'
non typé justement (mais correctement aligné pour n'importe quel type de
donnée).
et qu'il ne fallait pas caster le retour de malloc.
Ce n'est pas qu'il ne /faut/ pas, mais plutôt que c'est inutile de nos jours
(cette pratique horrible vient du fond des ages pré-ANSI, donc avant 1989).
Bref, on est plus au moyen-age...
Dans la FAQ, tu trouveras d'autres arguments...
--
-ed- emdelYOURBRA@noos.fr [remove YOURBRA before answering me]
The C-language FAQ: http://www.eskimo.com/~scs/C-faq/top.html
<blank line>
FAQ de f.c.l.c : http://www.isty-info.uvsq.fr/~rumeau/fclc/
En résumé, l'astuce consiste à déclarer un tableau de pointeurs void, qui eux ont une taille. Je le déclare ainsi: void *result[N]; et je l'utilise comme suit: result[i]
Oui. Mais ce n'est pas une astuce. C'est la transcription directe de ton besoin.
Pour pouvoir fixer dynamiquement la taille de mon tableau, je pourrais utiliser un pointeur de pointeurs void (void **result), que je pourrais également adresser ainsi: &result[i] (après avoir alloué de la mémoire pour result)
Non. La manière d'adresser un élément de tableau est la même partout :
tableau[indice]
Avec un pointeur correctement initialisé on fait
*(pointeur + indice)
ce qui peut aussi s'écrire
pointeur[indice]
ce qui est très similaire, voire parfaitement identique. La différence (invisible à l'oeil nu) est que 'tableau' est une constante et que 'pointeur' est une variable. Attention par contre au comportement de sizeof qui lui est très différent. Un tableau 'contient' sa taille, un pointeur non (je parle de la taille de l'objet pointé bien sûr).
malloc() retourne un pointeur void * précisément pour ça : l'adresse retournée est : - correctement alignée pour n'importe quel type,
Ca par contre, je comprend pas. L'adresse est de toute façon unique, que l'on adresse ensuite des octets, des words , des quad...
Non. Sur certaines architectures, il est impossible d'adresser un int sur une adresse impaire.
Ca va être une adresse de la taille du bus, c'est tout, non?
Peut être, peut importe...
C'est pour ça que j'ai jamais compris pourquoi on récupèrait un type void,
On récupère un type 'void *', c'est à dire un pointeur sur objet 'universel' non typé justement (mais correctement aligné pour n'importe quel type de donnée).
et qu'il ne fallait pas caster le retour de malloc.
Ce n'est pas qu'il ne /faut/ pas, mais plutôt que c'est inutile de nos jours (cette pratique horrible vient du fond des ages pré-ANSI, donc avant 1989). Bref, on est plus au moyen-age...
Dans la FAQ, tu trouveras d'autres arguments...
-- -ed- [remove YOURBRA before answering me] The C-language FAQ: http://www.eskimo.com/~scs/C-faq/top.html <blank line> FAQ de f.c.l.c : http://www.isty-info.uvsq.fr/~rumeau/fclc/
Emmanuel Delahaye
In 'fr.comp.lang.c', DINH Viêt Hoà wrote:
D'ailleurs, peut-on déclarer une donnée void ?
Non. 'void' est /l'absence/ de type.
-- -ed- [remove YOURBRA before answering me] The C-language FAQ: http://www.eskimo.com/~scs/C-faq/top.html <blank line> FAQ de f.c.l.c : http://www.isty-info.uvsq.fr/~rumeau/fclc/
In 'fr.comp.lang.c', DINH Viêt Hoà <dinh.viet.hoa@free.fr> wrote:
D'ailleurs, peut-on déclarer une donnée void ?
Non. 'void' est /l'absence/ de type.
--
-ed- emdelYOURBRA@noos.fr [remove YOURBRA before answering me]
The C-language FAQ: http://www.eskimo.com/~scs/C-faq/top.html
<blank line>
FAQ de f.c.l.c : http://www.isty-info.uvsq.fr/~rumeau/fclc/
| In 'fr.comp.lang.c', DINH Viêt Hoà wrote: | | > D'ailleurs, peut-on déclarer une donnée void ? | | Non. 'void' est /l'absence/ de type.
pas toujours.
-- Gaby
Patrick \Zener\ BRUNET
Bonjour.
"Emmanuel Delahaye" a écrit dans le message news:
In 'fr.comp.lang.c', "Patrick "Zener" BRUNET" <http://zener131.free.fr/ContactMe> wrote:
Donc typiquement, si T est un type,
#define N 666 T * pT; int i;
pT = (T *) malloc( N * sizeof( T));
Ce cast n'est pas nécessaire. AMA, il ne fait qu'ajouter à la confusion.
Qu'est-ce qui ne va pas avec:
T *pT = malloc (N * sizeof *pT);
Heeeem !
Faut que je révise, à moins que C et C++ n'aient pas la même tolérance. Il me semblait bien que le détypage : T * -> void * était implicite, mais que le typage : void * -> T * devait être explicite.
Effectivement, je considère chaque cast comme une tapette à souris, mais souvent (avec les librairies plus ou moins bien conçues), je n'ai pas le choix.
Cordialement,
PZB
Bonjour.
"Emmanuel Delahaye" <emdelYOURBRA@noos.fr> a écrit dans le message news:
Xns93FABE7DA64AFhsnoservernet@130.133.1.4...
In 'fr.comp.lang.c', "Patrick "Zener" BRUNET"
<http://zener131.free.fr/ContactMe> wrote:
Donc typiquement, si T est un type,
#define N 666
T * pT;
int i;
pT = (T *) malloc( N * sizeof( T));
Ce cast n'est pas nécessaire. AMA, il ne fait qu'ajouter à la confusion.
Qu'est-ce qui ne va pas avec:
T *pT = malloc (N * sizeof *pT);
Heeeem !
Faut que je révise, à moins que C et C++ n'aient pas la même tolérance.
Il me semblait bien que le détypage :
T * -> void *
était implicite, mais que le typage :
void * -> T *
devait être explicite.
Effectivement, je considère chaque cast comme une tapette à souris, mais
souvent (avec les librairies plus ou moins bien conçues), je n'ai pas le
choix.
In 'fr.comp.lang.c', "Patrick "Zener" BRUNET" <http://zener131.free.fr/ContactMe> wrote:
Donc typiquement, si T est un type,
#define N 666 T * pT; int i;
pT = (T *) malloc( N * sizeof( T));
Ce cast n'est pas nécessaire. AMA, il ne fait qu'ajouter à la confusion.
Qu'est-ce qui ne va pas avec:
T *pT = malloc (N * sizeof *pT);
Heeeem !
Faut que je révise, à moins que C et C++ n'aient pas la même tolérance. Il me semblait bien que le détypage : T * -> void * était implicite, mais que le typage : void * -> T * devait être explicite.
Effectivement, je considère chaque cast comme une tapette à souris, mais souvent (avec les librairies plus ou moins bien conçues), je n'ai pas le choix.
| Bonjour. | | "Emmanuel Delahaye" a écrit dans le message news: | | > In 'fr.comp.lang.c', "Patrick "Zener" BRUNET" | > <http://zener131.free.fr/ContactMe> wrote: | > | > > Donc typiquement, si T est un type, | > > | > > #define N 666 | > > T * pT; | > > int i; | > > | > > pT = (T *) malloc( N * sizeof( T)); | > | > Ce cast n'est pas nécessaire.
il est juste utile.
| > Qu'est-ce qui ne va pas avec: | > | > T *pT = malloc (N * sizeof *pT); | > | Heeeem ! | Faut que je révise, à moins que C et C++ n'aient pas la même tolérance.
en C, la notion de type est, ahem, floue.
| Il me semblait bien que le détypage : | T * -> void * | était implicite,
c'est le cas en C et en C++.
| mais que le typage : | void * -> T * | devait être explicite.
en C++, oui. En C, pour je ne sais quelle raison, le comité C89 a décidé d'innover, donc créant de la confusion inutile.
| Effectivement, je considère chaque cast comme une tapette à souris, mais
| Bonjour.
|
| "Emmanuel Delahaye" <emdelYOURBRA@noos.fr> a écrit dans le message news:
| Xns93FABE7DA64AFhsnoservernet@130.133.1.4...
| > In 'fr.comp.lang.c', "Patrick "Zener" BRUNET"
| > <http://zener131.free.fr/ContactMe> wrote:
| >
| > > Donc typiquement, si T est un type,
| > >
| > > #define N 666
| > > T * pT;
| > > int i;
| > >
| > > pT = (T *) malloc( N * sizeof( T));
| >
| > Ce cast n'est pas nécessaire.
il est juste utile.
| > Qu'est-ce qui ne va pas avec:
| >
| > T *pT = malloc (N * sizeof *pT);
| >
| Heeeem !
| Faut que je révise, à moins que C et C++ n'aient pas la même tolérance.
en C, la notion de type est, ahem, floue.
| Il me semblait bien que le détypage :
| T * -> void *
| était implicite,
c'est le cas en C et en C++.
| mais que le typage :
| void * -> T *
| devait être explicite.
en C++, oui. En C, pour je ne sais quelle raison, le comité C89 a décidé
d'innover, donc créant de la confusion inutile.
| Effectivement, je considère chaque cast comme une tapette à souris, mais
| Bonjour. | | "Emmanuel Delahaye" a écrit dans le message news: | | > In 'fr.comp.lang.c', "Patrick "Zener" BRUNET" | > <http://zener131.free.fr/ContactMe> wrote: | > | > > Donc typiquement, si T est un type, | > > | > > #define N 666 | > > T * pT; | > > int i; | > > | > > pT = (T *) malloc( N * sizeof( T)); | > | > Ce cast n'est pas nécessaire.
il est juste utile.
| > Qu'est-ce qui ne va pas avec: | > | > T *pT = malloc (N * sizeof *pT); | > | Heeeem ! | Faut que je révise, à moins que C et C++ n'aient pas la même tolérance.
en C, la notion de type est, ahem, floue.
| Il me semblait bien que le détypage : | T * -> void * | était implicite,
c'est le cas en C et en C++.
| mais que le typage : | void * -> T * | devait être explicite.
en C++, oui. En C, pour je ne sais quelle raison, le comité C89 a décidé d'innover, donc créant de la confusion inutile.
| Effectivement, je considère chaque cast comme une tapette à souris, mais
