Discussion :

[siempre]

Bonsoir,
J'ai un fichier contient deux champs: objet et attribut nommé "exemple.txt" :

2 11
4 11
10 10
5 O1
.....
.....

Sachant que on a la même taille pour tous les attributs de tous les objets dans notre exemple on a la taille = 2.
Cette taille peut changer d'un exemple à l'autre donc on ne connait pas la taille d'attribut en avance.

Je voudrais calculer la taille de l'attribut puis vérifier si on dans ce fichier si on a au moins un objet qui possède un attribut tout à 1 c'est à dire la chaine "11" dans notre cas.
la fonction verifier() nous retourne 1 si il existe la chaine "11" sinon O.

Voici mon essai :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
int verifier(int taille)
{
FILE *fp;
char *chaine,s[100],attribut[32];
int i,trouve=0,objet=0;
chaine = (char *) malloc(taille);
for(i=0; i < taille; i++)
chaine[i]='1';
chaine[taille]='\0';
printf("chaine=%s\n",chaine);
pFTrie = fopen("exemple.txt","r");
while (fgets(s, 100, fp))
{
sscanf(s,"%d%s",objet,attribut);
if(memcmp(attribut,chaine,taille))
{
free(chaine);
fclose(fp);
return 1;
}
}
free(chaine);
fclose(fp);
return 0;
}
 
int main()
{
FILE *fp;
int trouve=0,taille;
fp=fopen("exemple.txt");
While (fgets(s,100,fp))
sscanf(s,"%d%s",&objet,attribut);
taille=strlen(attribut);
trouve = verifier(taille);
printf("valeur de retour %d\n",trouve);
 
return 0;
}

Mais, le message suivant n'affiche pas:
printf("valeur de retour %d\n",trouve);

-Pourquoi ?

lorsque je lance l'exécution après la compilation j'ai le message suivant:
HEAP CORRUPTION DETECTED : after normal (#95) at 0*01020068.
CRT detected that the application wrote to memory after end of heap buffer.


Ceci à cause d 'instruction free chaine(); dans la fonction verifier () car je supprime cette instruction donc l'exection se passe.
Mais, comment on va liberer l'espace dynamique louée par chaine[taille] ?
- l'allocation et la libération de l'espace dynamique char *chaine est bien définie ?
- Existe-t-il le type boolean comme un type des données ? comment le déclare ?
- On peut utiliser le type boolean comme valeur de retour pour la fonction verifier() ?

[Lucien63]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
chaine[taille]='\0';

Ici tu écrit en dehors de ton tableau !
le dernier élément du tableau à pour indice taille-1

[siempre]

Bonjour,

Voici le programme :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
int verifier(int taille)
{
FILE *fp;
char *chaine,s[100],attribut[32];
int i,trouve=0,objet=0;
chaine = (char *) malloc(taille);
for(i=0; i < taille; i++)
chaine[i]='1';
chaine[taille]='\0';
printf("chaine=%s\n",chaine);
fp = fopen("exemple.txt","r");
while (fgets(s, 100, fp))
{
sscanf(s,"%d%s",objet,attribut);
if(memcmp(attribut,chaine,taille))
{
free(chaine);
fclose(fp);
return 1;
}
}
free(chaine);
fclose(fp);
return 0;
}
 
int main()
{
FILE *fp;
char s[100],attribut[32];
int trouve=0,taille,objet;
fp=fopen("exemple.txt","r");
while (fgets(s,100,fp)!= NULL)
sscanf(s,"%d%s",&objet,attribut);
taille=strlen(attribut);
trouve = verifier(taille);
printf("valeur de retour %d\n",trouve);
 
return 0;
}

Non. on a taille= 2
Chaine[0]='1' et Chaine[1]='1'
et il faut ajouter '\0' à la fin de la chaine donc Chaine[taille]='\0'
Que pensez-vous ?

[jeroman]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
taille=strlen(attribut);
trouve = verifier(taille);

La fonction strlen() calcule la longueur de la chaîne de caractères s, sans compter le caractère nul `\0' final.

Dans la fonction "verifier" :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

chaine = (char *) malloc(taille+1);

[Lucien63]

Non. on a taille= 2
Chaine[0]='1' et Chaine[1]='1'
et il faut ajouter '\0' à la fin de la chaine donc Chaine[taille]='\0'
Que pensez-vous ?

ça fait 3 caractères à écrire les deux '1' et le '\0'
il te faut donc un tableau de taille 3
Les indices des tableaux vont toujours de 0 à Taille-1

[siempre]

Merci. Ca marche.
taille +1 ou lieu de taille.

Une seule question:
- quelle est la différence entre :
chaine = (char *) malloc((taille+1));
chaine = (char *) malloc((taille+1)*sizeof(char));

Les deux marchent.

[Médinoc]

sizeof(char) vaut 1 par définition.

Mais ça devient plus compliqué/intéressant quand on touche aux caractères larges (pour Unicode): sizeof(wchar_t) vaut souvent 2 ou 4, et sous Windows, sizeof(TCHAR) peut valoir 1 ou 2 selon les options, donc il devient important de les préciser.

[LordMacharius]

Une seule question:
- quelle est la différence entre :
chaine = (char *) malloc((taille+1));
chaine = (char *) malloc((taille+1)*sizeof(char));

Les deux marchent.

Selon ton systeme d'exploitation ton char sera sur 1octet ou plus de mémoire c'est différent entre unix et windows !
le sizeof est important pour la compatibilité avec d'autre systeme !
de même on préfèrera un sizeof(*chaine) a sizeof(char) pour la simple et bonne raison que le jour ou ta chaine de char* devient une chaine d'int* tu devra relire tout ton code pour changer tes malloc a cause du sizeof(char)

Je te conseillerai de te faire une fonction xmalloc qui vérifie la valeur de retour de ta fonction malloc et qui renvoi un pointer void*

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
 
void     *xmalloc(void *str, int size)
{
void    *string;
 
if ((string = malloc((size + 1) *sizeof(*str))) == NULL)
puts("Can't allocate Memory\n");
string[size] = '\0';
return (string);
}

de mémoire le compilo va râler a cause du pointer void* que tu lui passes.
C'est la meilleur solution que j'ai trouve pour ne pas oublier de vérifier mes valeurs de retour de fonctions systeme.

Tu peux aussi utiliser errno (RTFM hein ^^) pour avoir un message plus précis.

[Sve@r]

Je te conseillerai de te faire une fonction xmalloc qui vérifie la valeur de retour de ta fonction malloc et qui renvoi un pointer void*

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
 
void     *xmalloc(void *str, int size)
{
void    *string;
 
if ((string = malloc((size + 1) *sizeof(*str))) == NULL)
puts("Can't allocate Memory\n");
string[size] = '\0';
return (string);
}

sizeof(*str) => Sachant que "*str" est de type "void" je suis étonné que ta fonction fonctionne correctement !!! D'ailleurs quand un compilo râle, c'est qu'il y a une raison donc une bonne approche est de s'arranger pour qu'il ne râle plus.
Visiblement cette fonction étant destinée à allouer une chaine, autant rester en char !!!
Toutefois, la plus-value de cette fonction (par rapport à calloc qui initialise la zone allouée à 0) étant seulement de t'afficher un message sur la sortie standard (et même pas la sortie d'erreur), je doute de sa réelle utilité. Par ailleurs, les connaisseurs apprécieront le remplissage de string[size] même en cas d'allocation échouée (Emmanuel, surtout ne passe pas par là )...

[gl]

Selon ton systeme d'exploitation ton char sera sur 1octet ou plus de mémoire c'est différent entre unix et windows !
le sizeof est important pour la compatibilité avec d'autre systeme !

Par definition sizeof(char) vaut 1 (et ce quel que soit la taille de ton char : 1 octet, 9 bits, 4 octets, etc.), il s'agit de la référence.
Toutes les autres tailles sont données en fonction de celle-ci

de même on préfèrera un sizeof(*chaine) a sizeof(char) pour la simple et bonne raison que le jour ou ta chaine de char* devient une chaine d'int* tu devra relire tout ton code pour changer tes malloc a cause du sizeof(char)

Tout à fait d'accord sur ce point. A condition que chaine ne soit pas un void*.

Je te conseillerai de te faire une fonction xmalloc qui vérifie la valeur de retour de ta fonction malloc et qui renvoi un pointer void*

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
 
void     *xmalloc(void *str, int size)
{
void    *string;
 
if ((string = malloc((size + 1) *sizeof(*str))) == NULL)
puts("Can't allocate Memory\n");
string[size] = '\0';
return (string);
}

de mémoire le compilo va râler a cause du pointer void* que tu lui passes.
C'est la meilleur solution que j'ai trouve pour ne pas oublier de vérifier mes valeurs de retour de fonctions systeme.

Tu peux aussi utiliser errno (RTFM hein ^^) pour avoir un message plus précis.

Fonction fausse et inutile.
En plus des remarques déjà fournies par Sve@r (sizeof(void), message d'erreur sur la sortie standard dans une fonction couche basse, déréférencement d'un pointeur NULL), je rajouterais que :

• Je ne vois pas l'intérêt pour une fonction d'allocation mémoire générique d'allouer plus que nécessaire et de rajouter un 0 après la mémoire demandé.
• Si l'idée était de faire une fonction de gestion de chaîne de caractère, elle porte mal son nom, je ne vois pas l'intérêt d'utiliser des void* et surtout à quoi peut-elle bien servir puisque la chaîne, même correctement terminée, contient n'importe quoi. Si le but est de dupliquer une chaîne, la fonction strdup() (ou un implémentation personnelle de celle-ci lorsqu'elle n'est pas disponible) est plus efficace.

[LordMacharius]

Mouarf
c'est pas la fonction que j'utilise exactement !
simplement parce que j'utilise d'autre fonction de mon cru !

Celle qui est chez moi fait un zoli EXIT si je ne peux pas allouer mon pointeur ! et se sert de la sortie d'erreur .

Des que j'ai l'occasion je montrerai le code dont je me sert !

Je tiens aussi a préciser que je n'ai eu le droit qu'a malloc , des bêtes write et fonction essentiel pour faire un programme en C . (Je suis encore Étudiant ^^ dans une école ou les fonctions font 25lignes , et ou on recode tout ce dont on a besoin !)

Le but de cette fonction est juste d'allouer ma chaine et d'être sur d'avoir le caractère de fin !
gain de temps car je sais que j'ai pas a tester le caractère de fin de chaine ! De plus même si elle est remplie de rien du tout je ne test jamais ce que contient ma chaine je la remplie juste après mon allocation.

[Sve@r]

Mouarf
c'est pas la fonction que j'utilise exactement !
simplement parce que j'utilise d'autre fonction de mon cru !

Celle qui est chez moi fait un zoli EXIT si je ne peux pas allouer mon pointeur ! et se sert de la sortie d'erreur .

exit c'est uniquement à mettre dans le main. Un programme c'est comme des poupées russes. Si on rentre dans une fonction, on ressort par la fonction. Et comme on rentre par le main...

Des que j'ai l'occasion je montrerai le code dont je me sert !

Oui, ça nous intéresse...

Le but de cette fonction est juste d'allouer ma chaine et d'être sur d'avoir le caractère de fin !

calloc()

gain de temps car je sais que j'ai pas a tester le caractère de fin de chaine ! De plus même si elle est remplie de rien du tout

Justement ta zone ne contient pas "rien du tout" (le "rien" n'existe pas pour une variable) mais des octets aléatoires.

je ne test jamais ce que contient ma chaine je la remplie juste après mon allocation.

Et tu la remplis comment ? Via une fonction str (style strcpy()) ? Alors le '\0' est automatiquement positionné par la fonction (à l'exception de strncpy() si le nombre "n" est atteint)

[gl]

Celle qui est chez moi fait un zoli EXIT si je ne peux pas allouer mon pointeur ! et se sert de la sortie d'erreur .

L'utilisation d'un exit() ici résout certes une partie des problèmes remonté mais n'est pas forcément pertinent.
La sortie pure et simple et brutale d'un programme lorsqu'une telle erreur d'allocation est rencontrée n'est pas toujours une solution envisageable (il peut être nécessaire des logger l'erreur, d'enregistrer l'état en cours ou des modifications effectuées, de relâcher certains ressource, de continuer à fonctionner en mode dégradé, de différer la tentative d'allocation, etc.) et il est très rare qu'une fonction d'une couche aussi basse puisse prendre seule la décision du traitement à effectuer.

Bref, ce choix peut convenir dans certains cas mais est loin d'être généralisable et la fonction est difficilement réutilisable.

Le but de cette fonction est juste d'allouer ma chaine et d'être sur d'avoir le caractère de fin !
gain de temps car je sais que j'ai pas a tester le caractère de fin de chaine ! De plus même si elle est remplie de rien du tout je ne test jamais ce que contient ma chaine je la remplie juste après mon allocation.

Dans ce cas, le nom de la fonction et le type des paramètres est mal choisi.

En outre le fonctionnement n'est pas classique (allocation d'une taille supérieure à la demande) et, dans de nombreux cas, l'initialisation du tableau à sa création ou l'utilisation d'une fonction du type strdup() sera probablement plus pertinent.