Discussion :

[Pimax]

Bonjour a tous.
J'ai fait un programme de correcteur orthographique basique et j'ai essayé de l'optimisé un peu et surtout de faire mes Malloc/calloc et free proprement. Malheureusement je suis devant l'impasse devant le dernier probleme de ce programme.

J'ai une structure

Code :

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

1
2
3
4
typedef struct {
    unsigned int valeur;
    char* operation;
}element_cel;

Dans ma fonction j'initialise cette structure comme ceci :

Code :

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

element_cel res;            // Variable de resultat

ensuite j'initialise une variable sequence qui est mainte fois modifiée/copié avec strcpy/concatené avec strcat et une fois fini je voudrais la mettre dans res.operation.

Code :

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

res.operation = sequence;

Me fait pointer res.operation vers la zone memoire de sequence, donc je ne peut plus liberer sequence avant de renvoyer res.

J'aimerais savoir si y'a un moyen de copié le contenu de sequence dans res.operation sans transformer la zone ou pointe res.operation vers celle ou pointe sequence, ainsi je pouurais faire un free(sequence); et liberer la memoire que sequence occupe avant la fin de mon programme.

J'espere avoir été clair
Merci d'avance.

[Franck.H]

Si tu veux copier une chaîne il te faut pour rester portable, créer la fonction toi même ou en trouver une sur le net comme ici: http://c.developpez.com/sources/?page=VI#STRING_copier

Sinon, je ne vois pas bien où est le problème ! Si tu avais un code à l'appui pour illustrer ton problème ce serait pas mal

Si res.operation pointe sur sequence, il ne faut pas libérer sequence mais res.operation lorsque tu n'en as plus besoin, surtout si tu n'as plus accès à sequence directement par exemple, si tu sort de la fonction !

[Pimax]

Bon en gros ma fonction transf(X,Y) qui creer la sequence :

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
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
/***********************************************/
/************ Fonction TRANSF (X,Y) ************/
/***********************************************/
 
element_cel transf(char* X, char* Y)
{
 
    /* Initialisation des variables */
    unsigned int i,j;
    char * sequence, *tmp;
    unsigned int m=strlen(X);   // Taille de la chaine de caractere X
    unsigned int n= strlen(Y);  // Taille de la chaine de caractere Y
    element_cel res;            // Variable de resultat
    element_cel cop, del, ins;  // Variable temporaire
    element_cel ** tab;         // Definition du tableau a double entree
 
    /* Initialisation du tableau */
 
    tab = (element_cel **)malloc ( (m+1) * (sizeof (element_cel) ) );
 
    // test d'erreur d'allocation
    if( tab == NULL )
    {
        fprintf(stderr,"Allocation impossible");
        exit(EXIT_FAILURE);
    }
 
    for(i=0; i<m+1; i++)
    {
        tab[i] = (element_cel *) malloc ( (n+1) * (sizeof (element_cel) ) );
 
        // test d'erreur d'allocation
        if( tab[i] == NULL )
        {
            fprintf(stderr,"Allocation impossible");
            exit(EXIT_FAILURE);
        }
    }
 
    /* Fin initialisation */
 
    tab[0][0].valeur = 0;   // la valeur en 0,0 est toujours 0 car pas de transformation a faire
    tab[0][0].operation = ""; // Pas de transformation donc vide
 
    /* Initialisation des valeur du tableau pour i=0, 1<=j<=n et 1<=i<=m, j=0 */
 
    for(i=1; i<m+1; i++)
    {
        tab[i][0].valeur = tab[i-1][0].valeur+VAL_DEL;
        tab[i][0].operation = "Delete";
    }
 
    for(j=1; j<n+1;j++)
    {
        tab[0][j].valeur = tab[0][j-1].valeur+VAL_INS;
        tab[0][j].operation = "Insert";
    }
 
    /* Remplissage du tableau */
 
    for(i=1; i<m+1; i++)
    {
        for(j=1; j<n+1; j++)
        {
            /* Variable cop */
 
            if (X[i-1]==Y[j-1])
            {
                cop.valeur = tab[i-1][j-1].valeur+VAL_CPY;
                cop.operation = "Copy";
            } else
            {
                cop.valeur = UINT_MAX;
                cop.operation = "Copy";
            }
 
            /* Variable del */
 
            del.valeur = tab[i-1][j].valeur+VAL_DEL;
            del.operation = "Delete";
 
            /* Variable ins */
 
            ins.valeur = tab[i][j-1].valeur+VAL_INS;
            ins.operation = "Insert";
 
            /* Selection du F(i,j) */
 
            if(cop.valeur <= del.valeur && cop.valeur <= ins.valeur)
            {
                tab[i][j].valeur = cop.valeur;
                tab[i][j].operation = cop.operation;
            }else
            {
                if(ins.valeur < cop.valeur && ins.valeur <= del.valeur)
                {
                    tab[i][j].valeur = ins.valeur;
                    tab[i][j].operation = ins.operation;
                }else
                {
                    tab[i][j].valeur = del.valeur;
                    tab[i][j].operation = del.operation;
                }
            }
        }
    }
 
    /* Creation de la sequence de retour */
 
    sequence = (char *)calloc(1,sizeof(char));
 
    // test d'erreur d'allocation
    if( sequence == NULL )
    {
        fprintf(stderr,"Allocation impossible");
        exit(EXIT_FAILURE);
    }
 
    i = m;
    j = n;
 
    while(i!=0 || j!=0)
    {
        tmp = (char *)calloc((strlen(sequence) + strlen(tab[i][j].operation) + 2), (sizeof(char))); //initialisation tmp
 
        // test d'erreur d'allocation
        if( tmp == NULL )
        {
            fprintf(stderr,"Allocation impossible");
            exit(EXIT_FAILURE);
        }
 
        strcpy(tmp, tab[i][j].operation); // tmp <- operation
        strcat(tmp, " "); // tmp += " "
        strcat(tmp, sequence); // tmp += sequence
 
        free(sequence); // On libere la memoire de sequence
 
        sequence = (char *) calloc((strlen(tmp) + 1), (sizeof(char))); // on reinitialise sequence avec une nouvelle taille
 
        // test d'erreur d'allocation
        if( sequence == NULL )
        {
            fprintf(stderr,"Allocation impossible");
            exit(EXIT_FAILURE);
        }
 
        strcpy(sequence, tmp); // sequence <- tmp
 
        free(tmp); // On libere tmp
 
        /* On passe a f-1 */
 
        if(strcmp(tab[i][j].operation, "Copy") == 0)
        {
            i--;
            j--;
        }else
        {
            if(strcmp(tab[i][j].operation, "Delete") == 0)
            {
                i--;
            }else
            {
                j--;
            }
        }
    }
 
 
    /****** Mon test de tableau ****
 
    for(i=0; i<m+1; i++)
    {
        for(j=0; j<n+1; j++)
        {
            printf("i= %d; j= %d; valeur: %d et operation: %s\n",i , j, tab[i][j].valeur, tab[i][j].operation);
        }
    }
 
    ***** Fin de test de tableau ********/
 
    /* La variable de retour est initialisé */
 
    res.valeur = tab[m][n].valeur;
    res.operation = sequence;
 
    /* désallocation mémoire du tableau :  */
    for (i = 0; i < m+1; i++)
    {
        free(tab[i]);
    }
 
    free(tab);
 
    return res;
 
}

En gros j'aimerais vraiment liberer la memoire prise par sequence une fois le res de retour traité dans l'autre fonction (un fprintf de la chaine dans un fichier)

Le seul moyen que je vois sans la copié serais de transformer elem_cel transf( ...) en elem_cel * transf( ... ) mais je me disais au debut que cela n'aurait pas forcement été utile.

PS: Sinon ca va dans la fonction, c'est pas trop moche ??

[Franck.H]

Mais en considérant:

Code :

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

res.operation = sequence;

Tu n'as pas besoin de libérer sequence car tu le fait simplement pointer par l'intermédiaire de res.operation, tout va pour le mieux là, je vois aucun problème. La mémoire allouée se trouve sur le tas et donc n'a aucun lien direct avec la fonction, je vois pas en quoi c'est gênant.

C'est le même principe qu'une fonction par exemple strdup, elle alloue elle-même un espace assez grand pour copier la chaîne passée en argument et retourne cette adresse, là c'est un peu la même chose. Rien de bien choquant à priori.

Mais si tu tiens vraiment à libérer l'espace de sequence, utilise la fonction dont je t'ai passé le lien, ce qui donne en gros:

Code :

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

1
2
res.operation = str_dup (sequence);
free (sequence);

[Pimax]

Le programme effectivement tourne sans probleme. Je me demandais, en fait, si, comme je ne libere pas sequence de maniere manuelle, il ne serait pas liberé qu'au moment de l'arret de la fonction. Lorsque que je debuggue par gdb et que je regarde les adresses de sequence, les chaine de caractere sont toujours là.
J'avoue que je n'arrive pas a determiner quand reellement cette memoire pourrait etre reutiliser car lorsque mon programme tourne a fond, il ne prend que 6 Mo memoire (il charge un dictionnaire francais), donc je me dis que au bout d'un moment cette memoire est liberer.

Bon je m'embrouille alors on va dire que ca marche et puis voila (mince moi qui voulais bien tout diriger a la lettre ^^ )

Merci pour ton aide en tout cas et je vais essayer de faire des tests.

[Franck.H]

La mémoire est libérée par l'OS en fin normale du programme ou lorsque toi tu la fait. Le fait que le système est censé le faire lui-même ne veut pas dire que ca te dispense de le faire soyons clair

Ce que tu alloues dynamiquement se range dans une zone mémoire qu'on appel le tas et sa taille est en générale celle disponible. Cette mémoire n'est pas libérée lorsque tu quittes la fonction contrairement à une variable locale qui elle est en fait dans la pile.

Enfin si certains points te paraissent obscures pose des questions précises sur ce que tu ne comprend pas ou a du mal à comprendre