Bonsoir,

Je dois développer un petit bout de code permettant de gérer des éléments dans une table de hachage. Ces éléments seront des structures composées d'une chaîne de caractères (char *) et d'un entier.

Il m'est imposé de ne pas utiliser le char * directement mais de passer par le typedef suivant :

Code : Sélectionner tout - Visualiser dans une fenêtre à part
typedef char * Clef;
Cela afin de pouvoir changer de type utilisé de manière aisée.

J'ai donc développé le code suivant :

clef.h
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
#ifndef CLE_H
#define CLE_H
 
#include <string.h>
#include <stdlib.h>
 
typedef char * Clef;
 
void initialisationClef( Clef * pLaClef );
int copieClef( Clef * pClefDest, Clef * pClefSource );
int testamentClef( Clef * pLaClef );
 
#endif
clef.c
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
#include "clef.h"
 
void initialisationClef( Clef * pLaClef )
{
    // met le pointeur a NULL
    *pLaClef = NULL;
}
 
int copieClef( Clef * pClefDest, Clef * pClefSource )
{
    int iErreur = -1;
 
    // si le pointeur est a NULL
    if( *pClefDest == NULL )
    {
        // alloue la memoire pour la chaine de caractere
        *pClefDest = malloc( ( strlen( pClefSource ) * sizeof (char) ) + 1 );
 
        // copie la chaine de caractere
        strcpy( pClefDest, pClefSource );
 
        // aucune erreur
        iErreur = 0;
    }
    else
    {
        // erreur : essaie de copier une chaine de caractere sur un pointeur non nulle
        iErreur = 1;
    }
 
    // retourne le code d'erreur
    return iErreur;
}
 
int testamentClef( Clef * pLaClef )
{
    int iErreur = -1;
 
    // si le pointeur n'est pas a null
    if( *pLaClef != NULL )
    {
        // libere la memoire
        free( *pLaClef );
 
        // met le pointeur a NULL
        *pLaClef = NULL;
 
        iErreur = 0;
    }
    else
    {
        // Erreur : essaie de desallouer un pointeur nulle
        iErreur = 2;
    }
 
    // retourne le code d'erreur
    return iErreur;
}
main.c
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
 
#include "clef.h"
#include "stdio.h"
 
int main()
{
    char toto[5] = "toto";
    printf( "toto='%s'\n", toto );
 
    Clef clefCopieToto;
 
    printf( "toto='%s', clefCopieToto='%s'\n", toto, clefCopieToto );
 
    initialisationClef( &clefCopieToto );
    printf( "init. clef OK\n" );
 
    printf( "toto='%s', clefCopieToto='%s'\n", toto, clefCopieToto );
 
    copieClef( &clefCopieToto, (Clef *) toto );
    printf( "copie clef OK\n" );
 
    printf( "toto='%s', clefCopieToto='%s'\n", toto, clefCopieToto );
 
    testamentClef( &clefCopieToto );
    printf( "testament clef OK\n" );
 
    return 0;
}
Le seul soucis est que si je passe en paramètre directement le type clef (char*), mes modifications ne sont appliquées que dans la fonction et dès que je retourne dans le main les modification ont disparu.

J'ai donc décider de passer un pointeur sur clef (char **) afin que les modifications ne soient pas apportées sur une copie de la clef.

Le soucis est qu'il doit y avoir un concept qui m'échappe (cela fait un moment que je n'ai pas fait de C ) car ce bout de code n'est pas fonctionnelle. En effet j'obtiens une runtime error à la ligne (après la copie) :

Code : Sélectionner tout - Visualiser dans une fenêtre à part
printf( "toto='%s', clefCopieToto='%s'\n", toto, clefCopieToto );
J'imagine que mon malloc ou mon strcpy est flingué à cause de mon obligation de caster Clef* en char* ou autre.

Est-ce que quelqu'un aurait une idée sur la question ?

Merci d'avance,

BenJ

PS : je développe sous Ubuntu 10.4 avec CodeBloc et gcc.