Discussion :

[lilington]

bonjour.
mon probleme c'est que je charge des donnees depuis un fichier et que la taille du pointeur je l'ai qu'en regardant dans le fichier, j'aimerai faire une fonction comme celle ci

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
int loadmap(char path[i][j],char *map) //svp ne pas commenter i et j
{
   for(int k=1;k<i;k++)
   {
     lire_octetxxxdans_le fichier_pour_obtenir_taille;
     taille =x;
     map = realloc(map,sizeof(char)*(x*k));
     remplire_map;
     if (erreur)
     return 0;
  }
  return 1;
}

je rentre pas dans les detailles mon code marche deja correctement quand je mets le tout dans main. ma question est de savoir si je peux sans risque faire comme ecrit plus haut. car j'ai entendu dire que malloc ou ses derive dans une fonction c'est pas bien. donc ce que j'ai ecris plus haut est il faissable oui ou non ? si non de devrait-je faire car j'aimerai avoir ceci:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
char *map=malloc(sizeof(char));
 
if(loadmap(char path,map))
do
{
   rotation_map(map,angle);
   affiche_map(ecran,map);  //routine opengl;
   calcule_realite(temps,map); 
   memorise_nouvellemap(map);
   est_ce_fini();
}while(!finish);
free(map);

comme vous le voyez l'allocation est a l'exterieur mais la taille est modifier a l'interrieur et le free aussi est a l'exterieur, j'ai pas encore tape ce code car la fonction loadmap n'existe pas. ai-je le droit de faire ca sans risque?

[diogene]

car j'ai entendu dire que malloc ou ses derive dans une fonction c'est pas bien.

Ce n'est pas que c'est pas bien, mais l'utilisation de malloc pose le problème de faire le free au bon moment, sans l'oublier et une seule fois. C'est pourquoi, si on le peut, on essaye d'associer le malloc et le free associé dans une même fonction (comme dans ton deuxième code). Mais, ce n'est pas général et il y a bien des cas où ce n'est pas logique ni possible de procéder ainsi.

Dans ton ébauche de la fonction loadmap, prend des précautions indispensables sur l'utilisation de realloc :
- le realloc peut échouer
- et surtout, le realloc peut changer l'adresse du bloc alloué; donc la fonction doit renvoyer d'une façon ou d'une autre l'adresse du bloc alloué par le realloc.

[lilington]

en d'autre terme le faite d'avoir fait un malloc hors de la fonction n'arrange pas trop le cas?
les reallocs successifs peuvent effectivement changer l'adresse du debut de bloc mais je pensais que justement le map=realloc permettait d'obtenir la nouvelle adresse?!

[diogene]

Oui, mais il faut retransmettre cette nouvelle valeur à la fonction appelante, sinon elle va continuer à travailler sur l'ancienne adresse devenue illégale -> plantage

[lilington]

retransmetre? je fait un

Code :

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

1
2
 
  map=loadmap(path,map);

avec

Code :

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

1
2
3
4
5
6
7
8
 
  char *loadmap(char path[][],char *map)
  {
    .....
   map=realloc(.....);
    .....
   return map;
  }

ce code est 'il ce qu'il faut faire?

[diogene]

Par exemple.
La difficulté est maintenant de prendre aussi en compte le cas où la reallocation a échouée.

[lilington]

en faite ya pas vraiment de difficulte pour la reallocation si ca echou je renvois NULL et j'arrete le programme car la suite du programme n'est envisageable que si le pointeur contient TOUTES les donnees charge depuis des fichiers, s'il manque une seule c'est pas bon. donc si la reallocation echoue je suppose que c'est pas assez d'espace contigue, je pense que realloc en plus de changer la taille deplace si il n'y pas d'espace contigue.
mais quand vous dites "par exemple". il y aurait il mieux? et comment faire ce mieux?
merci je pense qu'apres je pourrai mettre resolu

[diogene]

en faite ya pas vraiment de difficulte pour la reallocation si ca echou je renvois NULL et j'arrete le programme car la suite du programme n'est envisageable que si le pointeur contient TOUTES les donnees charge depuis des fichiers, s'il manque une seule c'est pas bon. donc si la reallocation echoue je suppose que c'est pas assez d'espace contigue, je pense que realloc en plus de changer la taille deplace si il n'y pas d'espace contigue.

Pour faire propre, avant de sortir de la fonction avec NULL, il faudrait faire un free sur ce qui a été alloué. Ceci implique une construction du style :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
char *loadmap(char path[][],char *map)
{
   char * p;
   .....
   p = realloc(map,.....); // il faut conserver map pour le free éventuel
   if(p == NULL) free(map);
   else
  {
     .....
  }
  return p;
}

mais quand vous dites "par exemple". il y aurait il mieux? et comment faire ce mieux?

L'autre possibilité (ne parlons de l'utilisation de globales ) est de passer par la liste des paramètres. Elle laisse la possibilité d'utiliser la valeur de retour pour renvoyer une autre information (par exemple, un signal d'erreur ou la taille nouvellement allouée,...)

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
void loadmap(char path[][],char **map)
{
   char * p;
   .....
   p = realloc(*map,.....);
   if(p == NULL) free(*map);
   else
  {
     .....
  }
  *map = p;
}
.....
loadmap(path,&map);

[lilington]

ca me fait un coup sur la tete moi qui pensais avoir presque tout compris sur les pointeurs.....! merci pour tout.
j'aivais fait la premier solution sans le free(map) j'y avais pas pense ca marche tres bien et avec des allocations un peu abusive histoire de chercher des noises.
mais la deuxieme option me convient plus en ce sens qu'effectivement elle me permet de pouvoir renvoyer autres choses. avant j'avais dans mon pointeur de 0 a 8 xmax(2octets),ymax(2octets),dimension,xentree(2octets),yentree(2octets) ce qui me prennait bien 9octets au total dans mon pointeur mais la je peux avec la deuxieme methode renvoyer une structure ou un tableau

Code :

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

1
2
3
4
5
6
7
8
9
 
 
char *loadmap(....)
{
  char tbl[9];
  .......
  *map=p;
  return tbl;  //ou plus simplement une structure c'est meme mieux 
}

dans ce cas mon pointeur map n'aura que les donnees de la map
encore merci.

[Médinoc]

Le truc qui me parait bizarre dans ton loadmap(), c'est que si tu lis la taille au début, pourquoi utiliser realloc() plutôt qu'un simple malloc() ?

[lilington]

la taille c'est a la fin que j'ajoute dans le pointeur je fait realloc(taille+9)
et a la fin je fait

Code :

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

*map=quelquechoses; *(map+1)=autrechose;.......*(map+8)=dernier_info;

donc pour repondra a ta question je n'utilise pas malloc car je ne connaitrai la taille qu'apres le dernier realloc().

[lilington]

salut, je reviens encore sur le sujet mais enfaite je sais pas si je devrai en ouvrire un autre. Mon probleme est similaire au precedent.
ce que je veux c'est comprendre comment certaine librairie fond pour avoir des fonctions de ce type:

Code :

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

stuct  quelconque* function(param);

pour etre plus claire je vais faire un bout de code et je poserai la question apres:

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
stuct Mat
{
  unsigned int row;
  unsigned int col;
  float *data;
};
 
int main(void)
{
   stuct Mat *A = fonction(2,2,tbl) ;//avec tbl un tableau de 2X2
   ...
   ...
   releaseMat(&A);
   return 0;
}

on voit la que la fonction en question renvoit un pointeur vers une stucture Mat
et prend comme argument la taille du tableau et les donner a mettres dans la structure.
la question est vu que la fonction ne prends pas le pointeur comme parametre,
comment se fait l'allocation pour avant la copie des donnees, j'ai essayer des trucs mais j'ai eu a chaque fois le fameux "Erreur de segmentation"
example de fonctionsqui utilise ca: cvLoadImage avec opencv

c'est surtout que comprendre comment ca se fait me permettrai d'ecrire des librairies utilisables la ou je bosse pour faciliter un peu le developpement ici.
merci

[Médinoc]

Je n'arrive pas à voir le problème...

[jeroman]

la question est vu que la fonction ne prends pas le pointeur comme parametre,
comment se fait l'allocation pour avant la copie des donnees, j'ai essayer des trucs mais j'ai eu a chaque fois le fameux "Erreur de segmentation"

Si je comprends bien, tu passes à ta fonction un tableau avec sa taille, et tu veux le copier dans de la mémoire allouée ? (Elle est pas super compréhensible ta question, essaye de t'exprimer plus clairement)
Si c'est le cas, tu peux utiliser un malloc dans ta fonction, et retourner le pointeur.

[lilington]

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
struct Mat
{
    int i;
    int j;
    char *data;
};
 
struct Mat* fillMat(int row,int col,char **mat);
 
int main()
{
    int i,j;
    char tbl[2][2]={{0,2},{9,2}};
 
    struct Mat *matt = fillMat(2,2,tbl);
 
    for(i=0;i<4;i++)
            printf("%d  ",matt->data[i]);
    return 0;
}
 
struct Mat* fillMat(int row,int col,char **mat)
{
    struct Mat *A;
    A->i=row;
    A->j=col;
    A->data = (char *) malloc(row*col*sizeof(char)+1);
    int i,j,index=0;
 
    for(i=0;i<2;i++)
        for(j=0;j<2;j++)
            A->data[index++]=mat[i][j];
 
    return A;
}

cd code compile sans erreur mais a une erreure de segmentation.
et dans la fonction fillMat. voila le probleme. j'ai visiblement mal compris quelque chose avec mon allocation

[Médinoc]

char** n'est pas le même type que char (*)[2].

[lilington]

merci mais la n'est pas la quesiton car en remplacant par

Code :

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

char **tbl={{0,2},{9,2}};

le probleme reste entier. j'irai meme plus loin:
si je remplace la fonction fillMat par loadMat qui chargerai la matrice depuis par exemple un fichier ou en valeur imediate comme dans mon example:

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
struct Mat* loadMat()
{
    struct Mat *A;
    int i,j,index=0;
    char **tbl={{0,2},{9,2}};
    A->i=2;
    A->j=2;
    A->data = (char *) malloc(2*2*sizeof(char)+1);
 
 
    for(i=0;i<2;i++)
        for(j=0;j<2;j++)
            A->data[index++]=tbl[i][j];
 
    return A;
}

l'erreure de segmentation est encore la. bon je fais un debuggage pas a pas et j'ai l'erreur des la ligne

A->i=2;

[jeroman]

Rien ne te choque ??

Code :

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

1
2
3
 struct Mat *A;
A->i=2;
A->j=2;

Un indice : A vaut combien ?

[lilington]

heuu je suppose que j'ai pas le droit et que je dois faire avant:

Code :

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

1
2
 struct Mat *A,P;
    A=&P;

si oui j'ai tester et ca marche mais l'erreure reviens au niveau de

Code :

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

A->data[index++]=tbl[i][j];

c'est bon j'avoue je suis un peu perdu.
ce que je cherche c'est pas vraiment la solution mais une explication pour eviter de faire des betises a l'avenir. Merci pour la vitesse d'execution de votre part. merci

[jeroman]

Tu peux essayer un truc du style :

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
#include <stdlib.h>
#include <stdio.h>
 
struct Mat
{
    int i;
    int j;
    char *data;
};
 
struct Mat* fillMat(int,int,char*);
 
int main(void)
{
    int i,j;
    char tbl[2][2]={{0,2},{9,2}};
 
    struct Mat *matt = fillMat(2,2,&tbl[0][0]);
    if (matt!=NULL)
    {
        for (i=0; i<matt->i ; i++)
        {
            for(j=0; j<matt->j ; j++)
            {
                printf("%d  ",matt->data[i*matt->j + j] );
            }
            printf("\n");
        }
        free(matt);
    }
    return 0;
}
 
struct Mat* fillMat(int row,int col,char *mat)
{
    int i,j,index=0;
    struct Mat *A;
    if ( (A=malloc(sizeof (struct Mat))) !=NULL)
    {
        A->i=row;
        A->j=col;
        if ( (A->data=malloc(row*col*sizeof *(A->data))) !=NULL)
        {
            for(i=0;i<2;i++)
            {
                for(j=0;j<2;j++)
                {
                    A->data[index]=mat[index];
                    index++;
                }
            }
        }
    }
    return A;
}

[ EDIT : modif du code ]