J'ai vu dans un bouquin de cours de langage C sur les pointeurs
l'algorithme suivant:
main( )
{
float * pr1,*pr2,*pr3,somme=0;
/*allocation dynamique */
pr1=malloc(sizeof(float));
pr2=malloc(sizeof(float));
pr3=malloc(sizeof(float));
/*saisie*/
printf("Entrez 3 notes: ");
scanf("%f %f %f ",pr1,pr2,pr3);
/*calcul de la somme*/
somme=*pr1+ *pr2+ *pr3;
/*calcul de la moyenne*/
printf("Moyenne :%f n ",somme/3);
/*liberation de la mémoire*/
free(pr1);
free(pr2);
free(pr3);
}
Mes questions sont:
-les pointeurs ont été déclaré initialement à la première
instruction,pourquoi en plus une allocation dynamique avec malloc( ) et
free( )?Est-elle nécessaire?
-aurai-je pu utiliser l'allocation dynamique sans avoir au préalable
déclaré mes pointeurs comme à la première instruction?
J'ai vu dans un bouquin de cours de langage C sur les pointeurs
l'algorithme suivant:
main( )
{
float * pr1,*pr2,*pr3,somme=0;
/*allocation dynamique */
pr1=malloc(sizeof(float));
pr2=malloc(sizeof(float));
pr3=malloc(sizeof(float));
/*saisie*/
printf("Entrez 3 notes: ");
scanf("%f %f %f ",pr1,pr2,pr3);
/*calcul de la somme*/
somme=*pr1+ *pr2+ *pr3;
/*calcul de la moyenne*/
printf("Moyenne :%f n ",somme/3);
/*liberation de la mémoire*/
free(pr1);
free(pr2);
free(pr3);
}
Mes questions sont:
-les pointeurs ont été déclaré initialement à la première
instruction,pourquoi en plus une allocation dynamique avec malloc( ) et
free( )?Est-elle nécessaire?
-aurai-je pu utiliser l'allocation dynamique sans avoir au préalable
déclaré mes pointeurs comme à la première instruction?
J'ai vu dans un bouquin de cours de langage C sur les pointeurs
l'algorithme suivant:
main( )
{
float * pr1,*pr2,*pr3,somme=0;
/*allocation dynamique */
pr1=malloc(sizeof(float));
pr2=malloc(sizeof(float));
pr3=malloc(sizeof(float));
/*saisie*/
printf("Entrez 3 notes: ");
scanf("%f %f %f ",pr1,pr2,pr3);
/*calcul de la somme*/
somme=*pr1+ *pr2+ *pr3;
/*calcul de la moyenne*/
printf("Moyenne :%f n ",somme/3);
/*liberation de la mémoire*/
free(pr1);
free(pr2);
free(pr3);
}
Mes questions sont:
-les pointeurs ont été déclaré initialement à la première
instruction,pourquoi en plus une allocation dynamique avec malloc( ) et
free( )?Est-elle nécessaire?
-aurai-je pu utiliser l'allocation dynamique sans avoir au préalable
déclaré mes pointeurs comme à la première instruction?
Eric Levenez a écritDonc si tu as trouvé ce code dans un bouquin : poubelle direct.
Je vous trouve un tantinet intégriste.
Essayez de montrer l'utilisation d'un pointeur à un débutant
AMHA il vaut mieux commencer par du code simpliste puis le
critiquer en expliquant ses défauts pour ensuite aboutir
au code propre.
Eric Levenez a écrit
Donc si tu as trouvé ce code dans un bouquin : poubelle direct.
Je vous trouve un tantinet intégriste.
Essayez de montrer l'utilisation d'un pointeur à un débutant
AMHA il vaut mieux commencer par du code simpliste puis le
critiquer en expliquant ses défauts pour ensuite aboutir
au code propre.
Eric Levenez a écritDonc si tu as trouvé ce code dans un bouquin : poubelle direct.
Je vous trouve un tantinet intégriste.
Essayez de montrer l'utilisation d'un pointeur à un débutant
AMHA il vaut mieux commencer par du code simpliste puis le
critiquer en expliquant ses défauts pour ensuite aboutir
au code propre.
int main(void) /* au minimum */
ou
int main(int argc, char **argv)
Ben non. Il me semble bien que
int main()
est tout à fait correct.
http://www.faqs.org/faqs/fr/comp/lang/faq-c-2/
8<------------------------------------------------
9.4 Quels sont les prototypes valides de main() ?
int main(void) /* au minimum */
ou
int main(int argc, char **argv)
Ben non. Il me semble bien que
int main()
est tout à fait correct.
http://www.faqs.org/faqs/fr/comp/lang/faq-c-2/
8<------------------------------------------------
9.4 Quels sont les prototypes valides de main() ?
int main(void) /* au minimum */
ou
int main(int argc, char **argv)
Ben non. Il me semble bien que
int main()
est tout à fait correct.
http://www.faqs.org/faqs/fr/comp/lang/faq-c-2/
8<------------------------------------------------
9.4 Quels sont les prototypes valides de main() ?
[...]Il ne faut pas confondre du code simpliste avec du mauvais code.
On peut avoir du code débile justifié par une progression pédagogique.
Si on n'a pas à disposition le fil du chapitre, on peut être injustement
négatif sur le bout de code proposé.
D'un coté, il y a sur ce groupe moribond un plaisir pervers à critiquer
toute tentative un peu imparfaite.
D'un autre coté, même (et surtout)
dans un ouvrage de niveau zéro je n'aurais pas osé proposer le code de
l'OP.
[...]
Il ne faut pas confondre du code simpliste avec du mauvais code.
On peut avoir du code débile justifié par une progression pédagogique.
Si on n'a pas à disposition le fil du chapitre, on peut être injustement
négatif sur le bout de code proposé.
D'un coté, il y a sur ce groupe moribond un plaisir pervers à critiquer
toute tentative un peu imparfaite.
D'un autre coté, même (et surtout)
dans un ouvrage de niveau zéro je n'aurais pas osé proposer le code de
l'OP.
[...]Il ne faut pas confondre du code simpliste avec du mauvais code.
On peut avoir du code débile justifié par une progression pédagogique.
Si on n'a pas à disposition le fil du chapitre, on peut être injustement
négatif sur le bout de code proposé.
D'un coté, il y a sur ce groupe moribond un plaisir pervers à critiquer
toute tentative un peu imparfaite.
D'un autre coté, même (et surtout)
dans un ouvrage de niveau zéro je n'aurais pas osé proposer le code de
l'OP.
Bruno Desthuilliers writes:bonjour,
J'ai vu dans un bouquin de cours de langage C sur les pointeurs
l'algorithme suivant:
main( )
Bon. Tu peux d'ors et déjà jeter le bouquin (ou caler une armoire
avec, ou t'en servir à d'autres fins si le papier est adéquat...)
C'est:
int main(void) /* au minimum */
ou
int main(int argc, char **argv)
Ça dépend du standard. En K&R,
Mes questions sont:
-les pointeurs ont été déclaré initialement à la première
instruction,pourquoi en plus une allocation dynamique avec malloc( ) et
free( )?Est-elle nécessaire?
Ca dépend de ce que tu veux faire. En l'occurrence, je ne vois pas de
besoin pour dans le code (pourri) en question. Mais es-tu sûr d'avoir
compris les notions de pointeur et d'allocation dynamique ?
Bonne question. La réponse à apporter serait que déclarer un pointeur
ne l'initialise pas! Il peut pointer n'importe où, et même être
invalide.
Si on ne l'initialise pas avec une adresse (soit obtenue par malloc,
soit prise par l'opérateur unaire &), ça peut planter si on le
déréférence.
-aurai-je pu utiliser l'allocation dynamique sans avoir au préalable
déclaré mes pointeurs comme à la première instruction?
On pourrait écrire:
float *pr1=malloc(sizeof(*pr1));
float *pr2=malloc(sizeof(*pr2));
float *pr3=malloc(sizeof(*pr3));
...
Bruno Desthuilliers <bdesth.quelquechose@free.quelquepart.fr> writes:
bonjour,
J'ai vu dans un bouquin de cours de langage C sur les pointeurs
l'algorithme suivant:
main( )
Bon. Tu peux d'ors et déjà jeter le bouquin (ou caler une armoire
avec, ou t'en servir à d'autres fins si le papier est adéquat...)
C'est:
int main(void) /* au minimum */
ou
int main(int argc, char **argv)
Ça dépend du standard. En K&R,
Mes questions sont:
-les pointeurs ont été déclaré initialement à la première
instruction,pourquoi en plus une allocation dynamique avec malloc( ) et
free( )?Est-elle nécessaire?
Ca dépend de ce que tu veux faire. En l'occurrence, je ne vois pas de
besoin pour dans le code (pourri) en question. Mais es-tu sûr d'avoir
compris les notions de pointeur et d'allocation dynamique ?
Bonne question. La réponse à apporter serait que déclarer un pointeur
ne l'initialise pas! Il peut pointer n'importe où, et même être
invalide.
Si on ne l'initialise pas avec une adresse (soit obtenue par malloc,
soit prise par l'opérateur unaire &), ça peut planter si on le
déréférence.
-aurai-je pu utiliser l'allocation dynamique sans avoir au préalable
déclaré mes pointeurs comme à la première instruction?
On pourrait écrire:
float *pr1=malloc(sizeof(*pr1));
float *pr2=malloc(sizeof(*pr2));
float *pr3=malloc(sizeof(*pr3));
...
Bruno Desthuilliers writes:bonjour,
J'ai vu dans un bouquin de cours de langage C sur les pointeurs
l'algorithme suivant:
main( )
Bon. Tu peux d'ors et déjà jeter le bouquin (ou caler une armoire
avec, ou t'en servir à d'autres fins si le papier est adéquat...)
C'est:
int main(void) /* au minimum */
ou
int main(int argc, char **argv)
Ça dépend du standard. En K&R,
Mes questions sont:
-les pointeurs ont été déclaré initialement à la première
instruction,pourquoi en plus une allocation dynamique avec malloc( ) et
free( )?Est-elle nécessaire?
Ca dépend de ce que tu veux faire. En l'occurrence, je ne vois pas de
besoin pour dans le code (pourri) en question. Mais es-tu sûr d'avoir
compris les notions de pointeur et d'allocation dynamique ?
Bonne question. La réponse à apporter serait que déclarer un pointeur
ne l'initialise pas! Il peut pointer n'importe où, et même être
invalide.
Si on ne l'initialise pas avec une adresse (soit obtenue par malloc,
soit prise par l'opérateur unaire &), ça peut planter si on le
déréférence.
-aurai-je pu utiliser l'allocation dynamique sans avoir au préalable
déclaré mes pointeurs comme à la première instruction?
On pourrait écrire:
float *pr1=malloc(sizeof(*pr1));
float *pr2=malloc(sizeof(*pr2));
float *pr3=malloc(sizeof(*pr3));
...
int main(void) /* au minimum */
ou
int main(int argc, char **argv)
Ben non. Il me semble bien que
int main()
est tout à fait correct.
int main(void) /* au minimum */
ou
int main(int argc, char **argv)
Ben non. Il me semble bien que
int main()
est tout à fait correct.
int main(void) /* au minimum */
ou
int main(int argc, char **argv)
Ben non. Il me semble bien que
int main()
est tout à fait correct.
(snip)Si le bouquin n'explique pas celà, il est de bien piètre qualité.
Un pointeur ne sert qu'à désigner une *autre* variable.
s/désigner une *autre* variable/stocker une adresse mémoire/
Le code
float* prt1;
déclare un pointeur prt1 qui désignera un float.
déclare une variable (de type pointeur sur float) ptr1, qui stockera une
adresse mémoire dont le contenu sera interprété comme un float quand on
déréférencera le pointeur (nb: opération consistant à lire le contenu du
bloc mémoire dont le pointeur donne l'adresse).
Mais ce float
n'est pas construit lorsque l'on déclare le pointeur.
L'instruction 'malloc(sizeof(float))' cherche de la place pour
stoquer un float. Si elle réussit (laissons de côté pour commencer
la getsion des échec), un tels float est créé.
s/un tels float est créé/un bloc mémoire d'une taille suffisante pour
stocker un float est réservée, et son adresse de départ retournée/.
ptr1= malloc(sizeof(float));
signifie alors que ptr1 désigne la variable nouvellement crée.
s/désigne la variable nouvellement crée/a pour valeur l'adresse de
départ du bloc mémoire réservé/.
Sans allocation dynamique, ptr1 désigne nimporte quoi.
float f=3.14;
float *ptr pf = &f;
Pas d'allocation de mémoire dynamique ici, et pourtant, pf pointe sur
une adresse valide....
(snip)
Si le bouquin n'explique pas celà, il est de bien piètre qualité.
Un pointeur ne sert qu'à désigner une *autre* variable.
s/désigner une *autre* variable/stocker une adresse mémoire/
Le code
float* prt1;
déclare un pointeur prt1 qui désignera un float.
déclare une variable (de type pointeur sur float) ptr1, qui stockera une
adresse mémoire dont le contenu sera interprété comme un float quand on
déréférencera le pointeur (nb: opération consistant à lire le contenu du
bloc mémoire dont le pointeur donne l'adresse).
Mais ce float
n'est pas construit lorsque l'on déclare le pointeur.
L'instruction 'malloc(sizeof(float))' cherche de la place pour
stoquer un float. Si elle réussit (laissons de côté pour commencer
la getsion des échec), un tels float est créé.
s/un tels float est créé/un bloc mémoire d'une taille suffisante pour
stocker un float est réservée, et son adresse de départ retournée/.
ptr1= malloc(sizeof(float));
signifie alors que ptr1 désigne la variable nouvellement crée.
s/désigne la variable nouvellement crée/a pour valeur l'adresse de
départ du bloc mémoire réservé/.
Sans allocation dynamique, ptr1 désigne nimporte quoi.
float f=3.14;
float *ptr pf = &f;
Pas d'allocation de mémoire dynamique ici, et pourtant, pf pointe sur
une adresse valide....
(snip)Si le bouquin n'explique pas celà, il est de bien piètre qualité.
Un pointeur ne sert qu'à désigner une *autre* variable.
s/désigner une *autre* variable/stocker une adresse mémoire/
Le code
float* prt1;
déclare un pointeur prt1 qui désignera un float.
déclare une variable (de type pointeur sur float) ptr1, qui stockera une
adresse mémoire dont le contenu sera interprété comme un float quand on
déréférencera le pointeur (nb: opération consistant à lire le contenu du
bloc mémoire dont le pointeur donne l'adresse).
Mais ce float
n'est pas construit lorsque l'on déclare le pointeur.
L'instruction 'malloc(sizeof(float))' cherche de la place pour
stoquer un float. Si elle réussit (laissons de côté pour commencer
la getsion des échec), un tels float est créé.
s/un tels float est créé/un bloc mémoire d'une taille suffisante pour
stocker un float est réservée, et son adresse de départ retournée/.
ptr1= malloc(sizeof(float));
signifie alors que ptr1 désigne la variable nouvellement crée.
s/désigne la variable nouvellement crée/a pour valeur l'adresse de
départ du bloc mémoire réservé/.
Sans allocation dynamique, ptr1 désigne nimporte quoi.
float f=3.14;
float *ptr pf = &f;
Pas d'allocation de mémoire dynamique ici, et pourtant, pf pointe sur
une adresse valide....
Bruno Desthuilliers a écrit :int main(void) /* au minimum */
ou
int main(int argc, char **argv)
Ben non. Il me semble bien que
int main()
est tout à fait correct. Le void ne sert que s'il s'agit
d'une déclaration de fonction, mais lors de la définition,
cela ne donne pas d'ambiguïté.
Bruno Desthuilliers a écrit :
int main(void) /* au minimum */
ou
int main(int argc, char **argv)
Ben non. Il me semble bien que
int main()
est tout à fait correct. Le void ne sert que s'il s'agit
d'une déclaration de fonction, mais lors de la définition,
cela ne donne pas d'ambiguïté.
Bruno Desthuilliers a écrit :int main(void) /* au minimum */
ou
int main(int argc, char **argv)
Ben non. Il me semble bien que
int main()
est tout à fait correct. Le void ne sert que s'il s'agit
d'une déclaration de fonction, mais lors de la définition,
cela ne donne pas d'ambiguïté.
Si le bouquin n'explique pas celà, il est de bien piètre qualité.
Un pointeur ne sert qu'à désigner une *autre* variable.
Le code
float* prt1;
déclare un pointeur prt1 qui désignera un float.
Mais ce float
n'est pas construit lorsque l'on déclare le pointeur.
L'instruction 'malloc(sizeof(float))' cherche de la place pour
stoquer un float. Si elle réussit (laissons de côté pour commencer
la getsion des échec), un tels float est créé.
ptr1= malloc(sizeof(float));
signifie alors que ptr1 désigne la variable nouvellement crée.
On y accède par *ptr1.
Sans allocation dynamique, ptr1 désigne nimporte quoi.
-aurai-je pu utiliser l'allocation dynamique sans avoir au préalable
déclaré mes pointeurs comme à la première instruction?
Et comment ? Un appel à 'malloc' réserve de la mémoire, mais si tu
ne stoque pas dans un pointeur où est cette mémoire, tu l'as perdu.
Si le bouquin n'explique pas celà, il est de bien piètre qualité.
Un pointeur ne sert qu'à désigner une *autre* variable.
Le code
float* prt1;
déclare un pointeur prt1 qui désignera un float.
Mais ce float
n'est pas construit lorsque l'on déclare le pointeur.
L'instruction 'malloc(sizeof(float))' cherche de la place pour
stoquer un float. Si elle réussit (laissons de côté pour commencer
la getsion des échec), un tels float est créé.
ptr1= malloc(sizeof(float));
signifie alors que ptr1 désigne la variable nouvellement crée.
On y accède par *ptr1.
Sans allocation dynamique, ptr1 désigne nimporte quoi.
-aurai-je pu utiliser l'allocation dynamique sans avoir au préalable
déclaré mes pointeurs comme à la première instruction?
Et comment ? Un appel à 'malloc' réserve de la mémoire, mais si tu
ne stoque pas dans un pointeur où est cette mémoire, tu l'as perdu.
Si le bouquin n'explique pas celà, il est de bien piètre qualité.
Un pointeur ne sert qu'à désigner une *autre* variable.
Le code
float* prt1;
déclare un pointeur prt1 qui désignera un float.
Mais ce float
n'est pas construit lorsque l'on déclare le pointeur.
L'instruction 'malloc(sizeof(float))' cherche de la place pour
stoquer un float. Si elle réussit (laissons de côté pour commencer
la getsion des échec), un tels float est créé.
ptr1= malloc(sizeof(float));
signifie alors que ptr1 désigne la variable nouvellement crée.
On y accède par *ptr1.
Sans allocation dynamique, ptr1 désigne nimporte quoi.
-aurai-je pu utiliser l'allocation dynamique sans avoir au préalable
déclaré mes pointeurs comme à la première instruction?
Et comment ? Un appel à 'malloc' réserve de la mémoire, mais si tu
ne stoque pas dans un pointeur où est cette mémoire, tu l'as perdu.
int main(void) /* au minimum */
ou
int main(int argc, char **argv)
Ben non. Il me semble bien que
int main()
est tout à fait correct.
http://www.faqs.org/faqs/fr/comp/lang/faq-c-2/
8<------------------------------------------------
9.4 Quels sont les prototypes valides de main() ?
Oui, mais il ne s'agit pas AMHA d'un prototype ici,
mais de la declaration de la fonction.
int main(void) /* au minimum */
ou
int main(int argc, char **argv)
Ben non. Il me semble bien que
int main()
est tout à fait correct.
http://www.faqs.org/faqs/fr/comp/lang/faq-c-2/
8<------------------------------------------------
9.4 Quels sont les prototypes valides de main() ?
Oui, mais il ne s'agit pas AMHA d'un prototype ici,
mais de la declaration de la fonction.
int main(void) /* au minimum */
ou
int main(int argc, char **argv)
Ben non. Il me semble bien que
int main()
est tout à fait correct.
http://www.faqs.org/faqs/fr/comp/lang/faq-c-2/
8<------------------------------------------------
9.4 Quels sont les prototypes valides de main() ?
Oui, mais il ne s'agit pas AMHA d'un prototype ici,
mais de la declaration de la fonction.
