créer un tableau à partir d'une table de hachage

Version imprimable

Voir 40 message(s) de cette discussion en une page

bonjour à tous,
j'ai un mot de type Chainon mot

Code:

1
2
3
4
5
6
7
8
typedef struct st_chainonMot ChainonMot;
 
typedef struct st_liste
{
	ChainonMot *pPremier;
} ListeMot;
 
typedef ListeMot TableHachageMot[TAILLEHASH];

ce mot contient une liste des coordonnées (numeros le lignes où il apparait)

Code:

1
2
3
4
5
6
typedef struct st_chainonCoord ChainonCoord;
 
typedef struct st_listeCoord
{
	ChainonCoord *pPremiere;
} ListeCoord;

Mon probleme c'est que j'aime créer un tableau de MotCompact à partir d'une table de hachage

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
int * CreerTableauLigne(ChainonMot const*pc,size_t taille)
{
 
    ChainonCoord  const *pcCoord;
    int * tableauLigne=malloc(taille*sizeof(int));
    if(tableauLigne!=NULL)
    {
        size_t i=0;
 
            int annex=-1;
            for(pcCoord=coord_GetPremierC(GetPtrCoordC(pc));pcCoord!=NULL;pcCoord=ptr_GetNextC(pc))
            {
                if(GetLigne(pc)!=annex)
                {
                   tableauLigne[i]=GetLigne(pcCoord);
                    annex=GetLigne(pcCoord);
                    i++;
                }
            }
 
    }
 
}

Code:

1
2
3
4
5
6
7
MotCompact* InitialiserMotCompact(ChainonMot* p,size_t  taille)
{
    MotCompact* MC;
    MC->sczMot=GetMot(p);
    MC->pLignes=CreerTableauLigne(p,taille);
 
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
MotCompact* CreerTableMotsCompacts(size_t n,TableHachageMot *DblTableHash1fr)
{
    MotCompact  *pRet=malloc( TAILLEHASH * TAILLEHASH *sizeof(MotCompact));
    int i=0,j,k;
    if(pRet!=NULL)
    {
        for(j=0;j<TAILLEHASH;j++)
        {
            for(k=0;k<TAILLEHASH;k++)
            {
                pRet[i]=InitialiserMotCompact(DblTableHash1fr[j][k],n);
                i++;
            }
         }
    }
    return  pRet;
}

dans la ligne en gras ya 2erreurs:
erreur: incompatible type for argument 1 of ‘InitialiserMotCompact’|
erreur: incompatible types in assignment|
des idées svp?
merci

01/11/2009, 18h15
LittleWhite
Bonjour,

Il y a une petite incohérence dans le code:

Nous avons:
Code:

1 2 TableHachageMot *DblTableHash1fr
Qui est donc un pointeur sur TableHachageMot. On peut aussi pensé que c'est un tableau à une dimension (ça doit en être un :)).

Mais lors de l'appel à InitialiserMotCompact, nous essayons d'utiliser le DblTableHash1fr, comme si c'était un tableau à double dimension ( du coup le compilateur râle ).

Comme InitialiserMotCompact accepte un pointeur sur un ChainonMot, il faudra plus ecrire quelque chose de ce genre ->
Code:

1 2 pRet[i]=InitialiserMotCompact(DblTableHash1fr[k].pPremier,n);
Mais du coup, il y a un des deux for, qui pourrait s'avérer inutile.

Merci LittleWhite,

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
MotCompact* CreerTableMotsCompacts(size_t n,TableHachageMot *DblTableHash1fr)
{
    MotCompact  *pRet=malloc( TAILLEHASH * TAILLEHASH *sizeof(MotCompact));
    int i=0,j,k;
    if(pRet!=NULL)
    {
        for(j=0;j<TAILLEHASH;j++)
        {
            for(k=0;k<TAILLEHASH;k++)
            {
                pRet[i]=InitialiserMotCompact(DblTableHash1fr[j][k].pPremier,n);
                i++;
            }
         }
    }
    return  pRet;
}

il m'affiche une seule erreur :
erreur: incompatible types in assignment|

01/11/2009, 18h57
LittleWhite
L'erreur vient du fait, que InitialiserMotCompact retourne un MotCompact* alors que l'on essaie d'écrire dans un MotCompact.
pRet[i] -> est un MotCompact
pRet -> est un MotCompact* .

Du coup, je propose en solution de déclaré pRet comme suit:
Code:

1 2 MotCompact **pRet=malloc( TAILLEHASH * TAILLEHASH *sizeof(MotCompact*));
Ce qui donne un tableau de pointeur de MotCompact.

Par contre, il faut aussi modifier le type de retour de CreerTableMotsCompacts()
Et je ne sais toujours pas si ce que je dis est une solution correcte :aie:
01/11/2009, 19h20
Pouet_forever
Il faut que tu modifies ta fonction aussi, tu déclares un pointeur sur MC mais tu n'alloues pas de mémoire. Et juste après tu tentes d'accéder à MC->XXX :
Code:

1 2 3 4 5 6 7 MotCompact* InitialiserMotCompact(ChainonMot* p,size_t taille) { MotCompact* MC; MC->sczMot=GetMot(p); MC->pLignes=CreerTableauLigne(p,taille); }

Merci Pouet,
voilà c'est fait ;)

Code:

1
2
3
4
5
6
MotCompact* InitialiserMotCompact(ChainonMot* p,size_t  taille)
{
    MotCompact* MC = malloc(sizeof(MotCompact));
    MC->sczMot=GetMot(p);
    MC->pLignes=CreerTableauLigne(p,taille);
}

dans la fonction principale j'ai fait :
Code:

1 2 MotCompact* MC = malloc(sizeof(MotCompact)); MC=CreerTableMotsCompacts(DblTableHash1fr);
mais il m'affiche une erreur du type :
|attention : assignment makes pointer from integer without a cast
je vois pas pourquoi ?
aussi là
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 MotCompact** CreerTableMotsCompacts(TableHachageMot *DblTableHash1fr) { size_t n; MotCompact **pRet=malloc( TAILLEHASH * TAILLEHASH *sizeof(MotCompact*)); int i=0,j,k; if(pRet!=NULL) { for(j=0;j<TAILLEHASH;j++) { for(k=0;k<TAILLEHASH;k++) { n=nombreLigne(&DblTableHash1fr[j][k]); pRet[i]=InitialiserMotCompact(&DblTableHash1fr[j][k],n); i++; } } } return pRet; }
il ma'affiche 2erreurs :
|erreur: conflicting types for ‘CreerTableMotsCompacts’|
erreur: previous implicit declaration of ‘CreerTableMotsCompacts’ was here|

01/11/2009, 21h28
LittleWhite
Pour la première partie, c'est la modification que j'ai suggeré qui cause des problèmes.
Il faut ecrire ceci:
Code:

1 2 3 MotCompact** MC = NULL; MC=CreerTableMotsCompacts(DblTableHash1fr);
On a pas besoin de faire un malloc dans ce cas là, car il sera fait dans la fonction CreerTableMotsCompacts();

Pour l'erreur suivante, c'est à cause que vous avez le prototype de la fonction ( début du fichier .c , ou fichier .h) qui est pas le même que celui ou la fonction est définie.
Il faudra mettre ceci:
Code:

1 2 MotCompact** CreerTableMotsCompacts(TableHachageMot *DblTableHash1fr)
aux deux endroits.
01/11/2009, 21h29
Pouet_forever

Ta fonction retourne un pointeur de pointeur, donc il faut le récupérer en tant que pointeur de pointeur.
Et il ne faut pas non plus allouer de la mémoire que tu as allouée dans ta fonction :

Code:

MotCompact** MC = CreerTableMotsCompacts(DblTableHash1fr);

bonjour,

Code:

1
2
3
4
5
6
7
8
9
10
MotCompact* RechercherMot(MotCompact const  pc[],char*  mot)
{
    int i;
    for(i=0;i<TAILLEHASH;i++)
    {
        if(strcmp(GetMotCompact(&pc[i]), mot ) == 0)
        return (&pc[i]);
    }
    return NULL;
}

j(ai une erreur de compilaltion :attention : return discards qualifiers from pointer target type|
des idées svp?
merci

02/11/2009, 01h08
Pouet_forever

Tu as 2 solutions :

1*) Tu enlèves le mot 'const' de ta fonction :

Code:

MotCompact* RechercherMot(MotCompact pc[],char* mot)

2*) Tu fais un cast :

Code:

return (MotCompact*)(&pc[i]);

Je préfère de loin la première solution :ccool:
02/11/2009, 13h39
Médinoc

Aussi, on peut faire mieux en triant le tableau après sa création (avec qsort()), car ça permet ensuite de rechercher avec bsearch(), qui est plus rapide qu'une recherche linéaire.
02/11/2009, 14h37
étoile de mer

ok , merci pour vos reponses;
je trie le tableau et puis je fais la recherche
02/11/2009, 14h41
Médinoc

D'abord, il faudrait qu'on corrige la fonction CreerTableMotsCompact pour qu'elle crée vraiment un tableau de MotCompact et non pas un tableau de pointeurs.

Sauf que j'ai un souci avec cette fonction :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
MotCompact** CreerTableMotsCompacts(TableHachageMot *DblTableHash1fr)
{
 
   MotCompact **pRet=malloc( TAILLEHASH * TAILLEHASH *sizeof(MotCompact*));
 
    int i=0,j,k;
    if(pRet!=NULL)
    {
        for(j=0;j<TAILLEHASH;j++)
        {
            for(k=0;k<TAILLEHASH;k++)
            {
              //  n=nombreLigne(&DblTableHash1fr[j][k]);
                pRet[i]=InitialiserMotCompact(&DblTableHash1fr[j][k]);
                i++;
            }
         }
    }
 
    return  pRet;
}

attention : passing argument 1 of ‘InitialiserMotCompact’ from incompatible pointer type|

02/11/2009, 14h45
Médinoc

Justement, il faut qu'on les modifie toutes les deux.

j'ai essayé ca comme on a déja fait

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
MotCompact* CreerTableMotsCompacts(TableHachageMot *DblTableHash1fr)
{

   MotCompact *pRet=malloc( TAILLEHASH * TAILLEHASH *sizeof*pRet);

    int i=0,j,k;
    if(pRet!=NULL)
    {
        for(j=0;j<TAILLEHASH;j++)
        {
            for(k=0;k<TAILLEHASH;k++)
            {
                pRet[i]=InitialiserMotCompact(&DblTableHash1fr[j][k]);
                i++;
            }
         }
    }

    return  pRet;
}

attention : passing argument 1 of ‘InitialiserMotCompact’ from incompatible pointer type|
erreur: incompatible types in assignment|

On va faire un InitialiserMotCompact() comme ça:

Code:

1
2
3
4
5
6
7
8
void InitialiserMotCompact(MotCompact *pThis, ChainonMot const *pc)
{
	pThis->pLignes = CreerTableauLigne(pc, GetNbLigne(pc));
	pThis->nbLignes = GetNbLigne(pc));
 
	/*On pourrait faire mieux avec un allocateur, mais on n'en est pas là visiblement.*/
	pThis->sczMot = strdup(GetMot(pc));
}

oui, merci,
mais là on doit modifier cette fonction non?

Code:

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
int * CreerTableauLigne(ChainonMot const*pc)
{
    size_t taille = GetNbLignes(pc);
    ChainonCoord const *pcCoord;
    int * tableauLigne=malloc(taille*sizeof(int));
    if(tableauLigne!=NULL)
    {
        size_t i=0;
 
            int annex=-1;
            for(pcCoord=coord_GetPremierC(GetPtrCoordC(pc));pcCoord!=NULL;pcCoord= coord_GetNextC(pcCoord))
            {
                if( GetLigne(pcCoord)!=annex)
                {
                   tableauLigne[i]=GetLigne(pcCoord);
                    annex=GetLigne(pcCoord);
                    i++;
                }
            }
            assert(i==taille);
 
    }
 
     return tableauLigne;
 
}

02/11/2009, 14h59
Médinoc

Celle-là, non.

CreerTableMotsCompacts() doit être modifiée, par contre.

Voir 40 message(s) de cette discussion en une page