sortie compilation :
------------------------------------------------------------------------
~/work/C/essais/quel_age%> gcc -o quel_age -framework Foundation
quel_age.c
quel_age.c: In function 'main':
quel_age.c:14: warning: incompatible implicit declaration of built-in
function 'malloc'
quel_age.c:17: warning: incompatible implicit declaration of built-in
function 'exit'
------------------------------------------------------------------------
utilisation :
------------------------------------------------------------------------
~/work/C/essais/quel_age%> ./quel_age
Quel age avez-vous ? 20
Vous avez 20 ans
------------------------------------------------------------------------
mes questions :
- 1 - que veulent dire les warnings ? par ex :
quel_age.c:14: warning: incompatible implicit declaration of built-in
function 'malloc'
de la ligne 14 :
memoireAllouee = malloc(sizeof(long)); // Allocation de la mémoire
- 2 - est-il toujours nécessaire d'allouer de la mémoire même pour un
simple int i par exemple ?
- 3 - pourquoi la déclaration de malloc est-elle implicite ?
- 4 - si gcc me dit cela c'est que j'aurais du en faire une déclaration
EXplicite non ? mais comment ?
- 3 - pourquoi la déclaration de malloc est-elle implicite ?
Parce que tu n'as indiqué son prototype nulle part.
- 4 - si gcc me dit cela c'est que j'aurais du en faire une déclaration EXplicite non ? mais comment ?
#include <stdlib.h>
malloc est déclarée dans stdlib.h (man malloc). exit aussi y est déclarée.
ok, merci bien ! -- une bévue
Harpo
Une bévue wrote:
- 1 - que veulent dire les warnings ?
Ca veut dire que tu n'as pas mis assez de sévérité de warnings sinon t'en aurais eu plus.
par ex : quel_age.c:14: warning: incompatible implicit declaration of built-in function 'malloc' de la ligne 14 : memoireAllouee = malloc(sizeof(long)); // Allocation de la mémoire
Cela veut dire que la fonction malloc() n'a pas été 'déclarée', en fait le compilatur devrait plutôt dire 'defined'. Quand une fonction n'est pas définie, le compilateur assume qu'elle retourne un int, or memoireAllouée est un pointeur sur un long, c'est pour cette raison qu'il signale une incompatibilité.
Les fonctions qui ne sont pas définies dans ton programme sont définies dans des .h, ici malloc() est défnie dans stdlib.h. il faut faire l'#include de stdlib.h qui fait la même chose que si tu faisais un copié-collé de ce fichier dans ton programme.
Par contre unistd.h n'est pas requis, ce sont des définitions de fonctions qui ne sont pas standard C mais qu'on est en droit d'attendre sur à peu près tous les système Unix. Ici il n'y a pas de telle fonction, le programme a du être écrit à une époque où malloc était défini dans unistd.h.
donc change unistd par stdlib
et utilise gcc avec -W -Wall pour voir le reste des warnings.
- 2 - est-il toujours nécessaire d'allouer de la mémoire même pour un simple int i par exemple ?
Non, il est même très rare que l'on alloue de la mémoire pour un simple integer, sauf dans les tutoriaux. On alloue de la mémoire pour plusieurs aisons : - lorsque la mémoire allouée doit être utilisé hors du scope (bloc, fonction) dans laquelle on est. - lorsque sa taille ne peut pas être définie lorsqu'on écrit le programme ou lorsqu'elle est trop grande. - lorsqu'on écrit un tutoriel sur malloc.
- 3 - pourquoi la déclaration de malloc est-elle implicite ?
Parce que lorsque une fonction n'est pas définie explicitement , elle est considérée retourner un int, je ne sais pas pourquoi mais ça doit être dans un standard pour ne pas faire planter les vieux programmes.
- 4 - si gcc me dit cela c'est que j'aurais du en faire une déclaration EXplicite non ?
Voilà !
mais comment ?
en faisant le #include du .h dans laquelle elle est définie. ici stdlib.h
Il y a encore quelques remarques à faire sur ce programme.
-- http://patrick.davalan.free.fr/
Une bévue wrote:
- 1 - que veulent dire les warnings ?
Ca veut dire que tu n'as pas mis assez de sévérité de warnings sinon
t'en aurais eu plus.
par ex :
quel_age.c:14: warning: incompatible implicit declaration of built-in
function 'malloc' de la ligne 14 :
memoireAllouee = malloc(sizeof(long)); // Allocation de la mémoire
Cela veut dire que la fonction malloc() n'a pas été 'déclarée', en fait
le compilatur devrait plutôt dire 'defined'.
Quand une fonction n'est pas définie, le compilateur assume qu'elle
retourne un int, or memoireAllouée est un pointeur sur un long, c'est
pour cette raison qu'il signale une incompatibilité.
Les fonctions qui ne sont pas définies dans ton programme sont définies
dans des .h, ici malloc() est défnie dans stdlib.h.
il faut faire l'#include de stdlib.h qui fait la même chose que si tu
faisais un copié-collé de ce fichier dans ton programme.
Par contre unistd.h n'est pas requis, ce sont des définitions de
fonctions qui ne sont pas standard C mais qu'on est en droit d'attendre
sur à peu près tous les système Unix.
Ici il n'y a pas de telle fonction, le programme a du être écrit à une
époque où malloc était défini dans unistd.h.
donc change unistd par stdlib
et utilise gcc avec -W -Wall pour voir le reste des warnings.
- 2 - est-il toujours nécessaire d'allouer de la mémoire même pour un
simple int i par exemple ?
Non, il est même très rare que l'on alloue de la mémoire pour un simple
integer, sauf dans les tutoriaux.
On alloue de la mémoire pour plusieurs aisons :
- lorsque la mémoire allouée doit être utilisé hors du scope (bloc,
fonction) dans laquelle on est.
- lorsque sa taille ne peut pas être définie lorsqu'on écrit le
programme ou lorsqu'elle est trop grande.
- lorsqu'on écrit un tutoriel sur malloc.
- 3 - pourquoi la déclaration de malloc est-elle implicite ?
Parce que lorsque une fonction n'est pas définie explicitement , elle
est considérée retourner un int, je ne sais pas pourquoi mais ça doit
être dans un standard pour ne pas faire planter les vieux programmes.
- 4 - si gcc me dit cela c'est que j'aurais du en faire une
déclaration EXplicite non ?
Voilà !
mais comment ?
en faisant le #include du .h dans laquelle elle est définie.
ici stdlib.h
Il y a encore quelques remarques à faire sur ce programme.
Ca veut dire que tu n'as pas mis assez de sévérité de warnings sinon t'en aurais eu plus.
par ex : quel_age.c:14: warning: incompatible implicit declaration of built-in function 'malloc' de la ligne 14 : memoireAllouee = malloc(sizeof(long)); // Allocation de la mémoire
Cela veut dire que la fonction malloc() n'a pas été 'déclarée', en fait le compilatur devrait plutôt dire 'defined'. Quand une fonction n'est pas définie, le compilateur assume qu'elle retourne un int, or memoireAllouée est un pointeur sur un long, c'est pour cette raison qu'il signale une incompatibilité.
Les fonctions qui ne sont pas définies dans ton programme sont définies dans des .h, ici malloc() est défnie dans stdlib.h. il faut faire l'#include de stdlib.h qui fait la même chose que si tu faisais un copié-collé de ce fichier dans ton programme.
Par contre unistd.h n'est pas requis, ce sont des définitions de fonctions qui ne sont pas standard C mais qu'on est en droit d'attendre sur à peu près tous les système Unix. Ici il n'y a pas de telle fonction, le programme a du être écrit à une époque où malloc était défini dans unistd.h.
donc change unistd par stdlib
et utilise gcc avec -W -Wall pour voir le reste des warnings.
- 2 - est-il toujours nécessaire d'allouer de la mémoire même pour un simple int i par exemple ?
Non, il est même très rare que l'on alloue de la mémoire pour un simple integer, sauf dans les tutoriaux. On alloue de la mémoire pour plusieurs aisons : - lorsque la mémoire allouée doit être utilisé hors du scope (bloc, fonction) dans laquelle on est. - lorsque sa taille ne peut pas être définie lorsqu'on écrit le programme ou lorsqu'elle est trop grande. - lorsqu'on écrit un tutoriel sur malloc.
- 3 - pourquoi la déclaration de malloc est-elle implicite ?
Parce que lorsque une fonction n'est pas définie explicitement , elle est considérée retourner un int, je ne sais pas pourquoi mais ça doit être dans un standard pour ne pas faire planter les vieux programmes.
- 4 - si gcc me dit cela c'est que j'aurais du en faire une déclaration EXplicite non ?
Voilà !
mais comment ?
en faisant le #include du .h dans laquelle elle est définie. ici stdlib.h
Il y a encore quelques remarques à faire sur ce programme.
-- http://patrick.davalan.free.fr/
pere.noel
Harpo wrote:
donc change unistd par stdlib
et utilise gcc avec -W -Wall pour voir le reste des warnings.
OK.
- 2 - est-il toujours nécessaire d'allouer de la mémoire même pour un simple int i par exemple ?
Non, il est même très rare que l'on alloue de la mémoire pour un simple integer, sauf dans les tutoriaux. On alloue de la mémoire pour plusieurs aisons : - lorsque la mémoire allouée doit être utilisé hors du scope (bloc, fonction) dans laquelle on est. - lorsque sa taille ne peut pas être définie lorsqu'on écrit le programme ou lorsqu'elle est trop grande. - lorsqu'on écrit un tutoriel sur malloc.
ok pigé )))
- 3 - pourquoi la déclaration de malloc est-elle implicite ?
Parce que lorsque une fonction n'est pas définie explicitement , elle est considérée retourner un int, je ne sais pas pourquoi mais ça doit être dans un standard pour ne pas faire planter les vieux programmes.
- 4 - si gcc me dit cela c'est que j'aurais du en faire une déclaration EXplicite non ?
Voilà !
mais comment ?
en faisant le #include du .h dans laquelle elle est définie. ici stdlib.h
ok merci, c"est fait !
Il y a encore quelques remarques à faire sur ce programme.
ah ? ça m'intéresse car j'aimerais pouvour définir une struct FileName de 256 chars (255 en fait because ) et une autre Path de longueur variable disons 4 * FileName au départ et réallouer au fur à mesure du découpage d'un char * mon_path="/path/to/a/given/file"
ici 5
l'idée étant "auto-pédagogique" et m'initiant à malloc realloc free sur un tableau_pointeur.
dans la struc FileName je ne m'intéresse pas à adresser chaque caractère...
par contre dans Path si, je m'intéresse à chaque élément du Path, par ex (k précédent) pouvoir sortir :
Path my_path="/path/to/a/given/file" my_path.parent="/path/to/a/given" et : my_path.basename="file" -- une bévue
Harpo <invalid@invalid.invalid> wrote:
donc change unistd par stdlib
et utilise gcc avec -W -Wall pour voir le reste des warnings.
OK.
- 2 - est-il toujours nécessaire d'allouer de la mémoire même pour un
simple int i par exemple ?
Non, il est même très rare que l'on alloue de la mémoire pour un simple
integer, sauf dans les tutoriaux.
On alloue de la mémoire pour plusieurs aisons :
- lorsque la mémoire allouée doit être utilisé hors du scope (bloc,
fonction) dans laquelle on est.
- lorsque sa taille ne peut pas être définie lorsqu'on écrit le
programme ou lorsqu'elle est trop grande.
- lorsqu'on écrit un tutoriel sur malloc.
ok pigé )))
- 3 - pourquoi la déclaration de malloc est-elle implicite ?
Parce que lorsque une fonction n'est pas définie explicitement , elle
est considérée retourner un int, je ne sais pas pourquoi mais ça doit
être dans un standard pour ne pas faire planter les vieux programmes.
- 4 - si gcc me dit cela c'est que j'aurais du en faire une
déclaration EXplicite non ?
Voilà !
mais comment ?
en faisant le #include du .h dans laquelle elle est définie.
ici stdlib.h
ok merci, c"est fait !
Il y a encore quelques remarques à faire sur ce programme.
ah ? ça m'intéresse car j'aimerais pouvour définir une struct FileName
de 256 chars (255 en fait because ) et une autre Path de longueur
variable disons 4 * FileName au départ et réallouer au fur à mesure du
découpage d'un char * mon_path="/path/to/a/given/file"
ici 5
l'idée étant "auto-pédagogique" et m'initiant à malloc realloc free sur
un tableau_pointeur.
dans la struc FileName je ne m'intéresse pas à adresser chaque
caractère...
par contre dans Path si, je m'intéresse à chaque élément du Path, par ex
(k précédent) pouvoir sortir :
Path my_path="/path/to/a/given/file"
my_path.parent="/path/to/a/given"
et :
my_path.basename="file"
--
une bévue
et utilise gcc avec -W -Wall pour voir le reste des warnings.
OK.
- 2 - est-il toujours nécessaire d'allouer de la mémoire même pour un simple int i par exemple ?
Non, il est même très rare que l'on alloue de la mémoire pour un simple integer, sauf dans les tutoriaux. On alloue de la mémoire pour plusieurs aisons : - lorsque la mémoire allouée doit être utilisé hors du scope (bloc, fonction) dans laquelle on est. - lorsque sa taille ne peut pas être définie lorsqu'on écrit le programme ou lorsqu'elle est trop grande. - lorsqu'on écrit un tutoriel sur malloc.
ok pigé )))
- 3 - pourquoi la déclaration de malloc est-elle implicite ?
Parce que lorsque une fonction n'est pas définie explicitement , elle est considérée retourner un int, je ne sais pas pourquoi mais ça doit être dans un standard pour ne pas faire planter les vieux programmes.
- 4 - si gcc me dit cela c'est que j'aurais du en faire une déclaration EXplicite non ?
Voilà !
mais comment ?
en faisant le #include du .h dans laquelle elle est définie. ici stdlib.h
ok merci, c"est fait !
Il y a encore quelques remarques à faire sur ce programme.
ah ? ça m'intéresse car j'aimerais pouvour définir une struct FileName de 256 chars (255 en fait because ) et une autre Path de longueur variable disons 4 * FileName au départ et réallouer au fur à mesure du découpage d'un char * mon_path="/path/to/a/given/file"
ici 5
l'idée étant "auto-pédagogique" et m'initiant à malloc realloc free sur un tableau_pointeur.
dans la struc FileName je ne m'intéresse pas à adresser chaque caractère...
par contre dans Path si, je m'intéresse à chaque élément du Path, par ex (k précédent) pouvoir sortir :
Path my_path="/path/to/a/given/file" my_path.parent="/path/to/a/given" et : my_path.basename="file" -- une bévue
