Discussion :

[semaj_james]

Bonjour,

j'ai créé 2 matrices: tampon et *t. Je fais un memcpy:

Code :

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

1
2
 
memcpy(t,&tampon,l*colonne*sizeof(composante))

j'ai vu que *t prend l'adresse de tampon. Que devient ce qu'il y avait a l'adresse de *t avant le memcpy ? est ce que la zone mémoire est libérée ?

[DaZumba]

Ben non, tu fais une copie. Donc les donnees sont repetees deux fois. Evidemment, il est important que les zones memoires ne se recouvrent pas (notamment t et tampon doivent etre differents).

[semaj_james]

Comment faire alors pour liberer tampon ? J'ai essayé en faisant:

Code :

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

free(tampon)

mais apres j'ai n'importe quoi dans *t.

[DaZumba]

En relisant ton message, je vois que tu ecris que t prend l'adresse de tampon. Ce n'est pas possible. Il y a un probleme dans ton code (et je ne comprend pas pourquoi tu fais une copie d'un bloc memoire pour liberer ensuite l'original...).

[semaj_james]

J'ai ma matrice de départ *t que je veux reorganiser. Pour cela je stocke les valeurs de ma matrice *t dans la matrice tampon (qui est locale à la fonction). par exemple la ligne 1 devient la 5 etc. ensuite je veux que *t soit reorganisée comme tampon. je fais donc un memcpy. je veux supprimer ma matrice tampon qui ne me sert plus.

avant le memcpy:
tampon=0x412670
*t=0x412610

apres le memcpy:
tampon=0x412670
*t=0x412670

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
 
void reorg(mat_dyn *t,struct seg *tab2,int ligne,int colonne)
{
int k,j,l;
mat_dyn tampon;     
 
ini_matrice(&tampon,ligne,colonne);     
for(k=0;k<ligne;k++)
   {     
   l=tab2[k].nl;
    for(j=0;j<colonne;j++)
        tampon[adr_mrd(k,j,colonne)]=(*t)[adr_mrd(l,j,colonne)];
    }
l=ligne;
 
puts("matrice tampon:");
affiche_mrd(tampon,ligne,colonne);
 
puts("matrice t:");
affiche_mrd(*t,ligne,colonne);
 
// copie du contenu de la matrice tampon dans la matrice t
if(memcpy(t,&tampon,l*colonne*sizeof(composante))==NULL)
   printf("pointeur null");
 
puts("matrice triee:");
affiche_mrd(*t,ligne,colonne);
 
free(tampon);
 
puts("matrice triee apres free:");
affiche_mrd(*t,ligne,colonne);
 
}

[Trap D]

Ce bout de code

Code :

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

ini_matrice(&tampon,ligne,colonne);

est potentiellement dangereux : que se passe-t-il si l'initialisation n'a pas lieu ? Le programme s'arrête ?

[semaj_james]

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
/****************************************************************/
//initialisation de la matricre
 
void ini_matrice(mat_dyn *matrice,int ligne,int colonne)
{
int i,j;
 
    *matrice=alloc_mrd(ligne,colonne);
    if(*matrice==NULL)
       {
       printf("pas assez de memoire disponible\n");
       exit(1);
       }
    for(i=0;i<ligne;i++)
       for(j=0;j<colonne;j++)       
           (*matrice)[adr_mrd(i,j,colonne)]=0;
}

[DaZumba]

Je ne comprends pas tres bien ton code, et notamment ce qu'il doit faire.
Je vois:

Code :

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

1
2
 
mat_dyn tampon;

et

Code :

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

1
2
 
tampon[adr_mrd(k,j,colonne)]= ...

ce qui me fait penser que le type mat_dyn cache un pointeur, ce qui n'est jamais souhaitable.

Tu ecris plus haut que tu souhaites interchanger les lignes de ta matrice. Tu n'as pas besoin d'une ligne temporaire pour cela. Tu as juste besoin d'un pointeur temporaire.
Je m'explique avec un tableau a 2 dimensions.

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
 
int **array;
int i;
int nb_line = 3;
int nb_col = 2;
 
array = malloc(nb_lignes * sizeof *array);
for(i=0; i<nb_line; i++)
{
   array[i] = malloc(nb_col * sizeof **array);
}
 
/* maintenant, on a array[line][col]
 * avec 0 <= line <= nb_lines
 * et 0 <= col <= nb_col
 */

Si tu veux echanger deux lignes, il suffit d'echanger deux array[i]:

Code :

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

1
2
3
4
5
6
7
 
    int *temp;
 
   /* swap line 0 and 2 */
    temp = array[0];
    array[0] = array[2];
    array[2] = temp;

Pas de copie, juste un echange de pointeurs...

[semaj_james]

DaZumba
MessagePosté le: Lun Nov 14, 2005 17:56 Sujet du message:
Je ne comprends pas tres bien ton code, et notamment ce qu'il doit faire.
Je vois:
Code:

mat_dyn tampon;

et
Code:

tampon[adr_mrd(k,j,colonne)]= ...

ce qui me fait penser que le type mat_dyn cache un pointeur, ce qui n'est jamais souhaitable.

Pourquoi ce n'est pas souhaitable ?

Code :

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

1
2
3
4
5
6
7
8
9
#define composante int
typedef composante *mat_dyn;   //tableau d'entier
 
mat_dyn alloc_mrd(int nbl,int nbc)
 {return((mat_dyn)malloc((nbl)*nbc*sizeof(composante)));}
 
/* macro permettant d'acceder a l'element en ligne l et 
colonne c par m[l*nbc+c] */
#define adr_mrd(l,c,nbc) ((l)*(nbc)+(c))

int **array;

cela signifie que c'est un pointeur sur un tableau ??

Pas de copie, juste un echange de pointeurs...

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
void reorg(mat_dyn *t,struct seg *tab2,int ligne,int colonne)
{
int k,j;
mat_dyn tampon;     
 
ini_matrice(&tampon,ligne,colonne);     
for(k=0;k<ligne;k++)
   {     
   l=tab2[k].nl;
    for(j=0;j<colonne;j++)
        tampon[adr_mrd(k,j,colonne)]=(*t)[adr_mrd(l,j,colonne)];
    }
 
free(*t);
*t=tampon;
 
}