REcuperer des donnée d'un fichier binaire vers une tableau de hachage

Slt

j'ai des problemes avec ma fonction load qui me permet de recuperer les données d'un fichier binaire et de les transférer vers un tableau de hachages ... si qq'un trouve l'erreur ca serait sympa de me faire signe ... voila le code que j'ai pour le moment :

Dans liste.h

//============== INCLUDE =========================================================
#include <stdio.h>
#include <stdlib.h>

#ifndef liste_h
#define listeS_h

//============== DEFINE =========================================================
#define Max 50 // Nb d'element de la cle
#define Dim 3 // Nb d'element du tableau

// creation de la liste chainée

struct data
{
char cle[Max];
int rg;
struct data *suivant;
};

// Liste chainée
typedef data *liste;



// prototype

bool verif_chaine(char *chaine);
void main();
void free_memoire(liste head[]);
void save(liste tableau[]);
void affichage_id(liste hachage[],int id);
void load (liste tableau[]);
int hash(char *cle);
int rechercher(liste tableau[],char *chaine);
int ajout(char *cle,int valeur,int tmp,liste tableau[]);
//int ajout_elem(char *cle,liste tableau[]);

#endif

Dans fonction.cpp
//============== INCLUDE =========================================
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <conio.h>

// Appel du Header liste.h
#include "liste.h"

// **************************************************************
// Fonction ajout()
// **************************************************************
// Données : Table de hachage
// Resultat : Retourne la liste
// Fonction : Ajout d'une donnée de type clées à la liste
// User : Menu
// Remarques :

int ajout(char *cle,int valeur,int tmp ,liste tableau[])
{
//
// Fonction ajout d'une clé
//

// Declaration des variables locales
liste nouveau=NULL;
liste maillequimaille=tableau[valeur]; // Liste chainée

// Allocation dynamique de mémoire

nouveau=(liste)malloc(sizeof(data));
if(nouveau!=NULL)
{
// On copie les données saisies dans la structure
strcpy(nouveau->cle,cle);
nouveau->rg=tmp;
// On vide l'emplacement suivant
nouveau->suivant=NULL;
// Test si la liste est vide
if (tableau[valeur]==NULL)
{
tableau[valeur]=nouveau;
}
else
{
while(maillequimaille->suivant!=NULL)
{
// On positionne maillequimaille sur l'emplacement suivant
maillequimaille=maillequimaille->suivant;
}
// On positionne la tête de nouveau sur l'emplacement suivant
// de maillequimaille
maillequimaille->suivant=nouveau;
}
}
else
{
// Retourne le message d'erreur
printf("Erreur, Memoire Pleine !!");
system("pause");
}
// Incremente la variable globale
// contenant le rang d'un element
tmp++;
// Retourne le rang
return tmp;
}

// **************************************************************
// Fonction load()
// **************************************************************
// Données : Table de Hachage
// Resultat :
// Fonction : Charge la table de hachage depuis un fichier Binaire
// User : Menu
// Remarques :

void load(liste tableau[])
{
// Declaration des variables Locales
char nom[8];
int r=0,i=0;
int code=0;
FILE * entree;
liste temp=NULL;
// Initialisation
while (i<Max)
{
tableau[i]=NULL;
i++;
}
// Allocation de mémoire temporaire
temp=(liste) malloc(sizeof(data));

// Saisie nom de fichier
printf("Entrez un nom de fichier : ");
scanf("%s",&nom);

// Si le nom est supérieur à 8 caractère
if (strlen(nom)>8)
{
puts("8 Caractères Maximum !!!");
// Nouvelle saisie du nom
puts("Entrez un nom de fichier : ");
scanf("%s",&nom);
}
else
{
// Effectue le chargement
entree=fopen(nom,"rb");
if (entree==NULL)
{
// Affichage Message Erreur
perror("Erreur de Lecture ...");
// Sortie de la fonction
exit(0);
}
else
{
// Lis le fichier
fread(tableau,sizeof(data),1,entree);
while (!feof(entree))
{
// Ajoute un element et recupere son rang
r=ajout(temp->cle,hash(temp->cle),temp->rg,tableau);
}
}
// Ferme le fichier
fclose(entree);
}
}

// **************************************************************
// Fonction save()
// **************************************************************
// Données : Table de Hachage
// Resultat :
// Fonction : Sauvegarde la table de hachage dans un fichier Binaire
// User : Menu
// Remarques :

void save(liste tableau[])
{
// Declaration des variables Locales
char nom[8];
int i=0,j=0;
FILE * sortie;
printf("Entrez un nom de fichier : ");
scanf("%s",&nom);
// Si le nom est supérieur à 8 caractère
if (strlen(nom)>8)
{
puts("8 Caractères Maximum !!!");
puts("Entrez un nom de fichier : ");
scanf("%s",&nom);
}
else
{
// Effectue la sauvegarde
sortie=fopen(nom,"wb");
fwrite(tableau,sizeof(data),1,sortie);
fclose(sortie);
}
}

Whiteknight ... a B/X Shipper !