Modification d'une chaine de caracteres (char *) dans un fonction
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:
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:
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:
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:
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:
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.
