map<string,char,ConvOrdre>

Version imprimable

je veux utilisé une map ayant un certain orde, qui est défini par
Code:

1 2 3 4 5 6 7 8 9 10 class ConvOrdre { public: bool operator() (string n,string p) { return BinDec(n)<BinDec(p); // binraire vers décimale // le support binaire est une chaine string !! } };
je défini un conteneur :
static map<string,char,ConvOrdre> GenetiqueExt;
mais quand je fait
Code:

1 2 HuffmanExt[b.ChaineBits]=buffer[0]; // ChaineBits vien d'un fichier
il me prend pas tout enfin j'ai 43 éléments et il en prend que 40 ou 15 !!!
C'est pour le moins génant.
y a t-il une petite bétise ?
je supose que cela vient du fait de map<string,char> car avec l'inverse ca marche bien, mais pour l'ordre il faut que ca soit cet ordre !!
Merci Stany
P.S. la source est long elle fait 2000 lignes

01/05/2006, 22h56
Rafy
J'ai peur de ne pas trop comprendre ton problème....
Le prédicat que tu donne en 3ème paramètre template, sert à classer les char de ton map suivant un tri des clefs (en l'ocurence des string) qui leur sont associés...
buffer est un char* je suppose, tu dis que ça ne copie que 40 ou 15 éléments, mais des éléments de quoi ? un char c'est une char.... Dans ta ligne :
Code:

1 2 HuffmanExt[b.ChaineBits]=buffer[0]; // ChaineBits vien d'un fichier
Tu ajoutes dans ton map une clef nommée b.ChaineBits, qui doit être un string à laquelle tu associes le char buffer[0].
Si il y a déjà dans le map une clef qui est égalle à b.ChaineBits alors, la valeur associée à cette clef sera écrasée...
Quand tu dis que ça vient du map<string, char>, et qu'avec l'inverse ça marche bien.... De quel inverse tu parles ?
02/05/2006, 13h42
superspag
Effectivement... Quand tu fais
Code:

1 2 HuffmanExt[b.ChaineBits]=buffer[0];
Verifie que tes clés (b.ChaineBits) sons bien toutes differentes. Si tu appel ta map avec une clé déjà presente, tu n'ajoute pas un nouvel objet mais tu modifies l'existant...
02/05/2006, 19h11
Stany

En fait c'est comme si la map n'enregistrerai pas ce que je lui donne et la
b.ChaineBits est unique a chaque itération de la boucle while donc je ne comprend pas !!
02/05/2006, 19h25
Rafy

Donne nous le code de ta boucle...

j'ai une lecture sous console

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
59
60
61
62
 
les code lu et enregistré dans la map
0 01100
 
1 01110
2 0
3 00111100 !
4 0000000 '
5 0000110 ,
6 0111000 .
7 00000110 ?
8 0111100 A
9 00110000 B
10 00110110 C
11 00111110 G
12 00011000 H
13 000110 I
14 01100000 N
15 01100110 O
16 00111000 S
17 00001100 T
18 00001110 W
19 00011110 Y
20 0000 a
21 0111110 b
22 0011110 c
23 001110 d
24 000 e
25 0110000 f
26 0001110 g
27 001100 h
28 011100 i
29 00011100 j
30 0110110 k
31 011110 l
32 000000 m
33 0110 n
34 00000 o
35 00000000 p
36 011000 r
37 00110 s
38 00 t
39 0001100 u
40 01101100 v
41 0011100 w
42 0011000 y
MAP
0:t
0000110:s
01100:u
01110:g
00011000:y
011100:w
00011110:l
00110000:f
00110110:k
0111000:S
00111100:A
00111110:b
01100000:N
01100110:O
01101100:v

donc il y a un bléme
et le code

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
 
LireBinaire b;
b.Ouvrir(Convention,GENERIC_READ, OPEN_EXISTING );// ouverture du fichier convention
        if (b.Bon())
        {
            int Lettres;
            int Longeur;
        // nombre de lettre codé
            Lettres=b.LireChaineBinaire(0,9); 
            cout<<"Lettre G "<<  Lettres<<endl;     
        // longeur de la longeur de bit qui contient la longeur du code
            Longeur=b.LireChaineBinaire(9,14);
 
            int PosBinFi=24;
            int LongeurCode;
            /*  Lecture de la convention de fichier  */
            for(int y=0;y<Lettres;y++)
            { 
                buffer[0]=b.LireChaineBinaire(PosBinFi,PosBinFi+8); //cout<<b.ChaineBits<<" "<<buffer[0]<<endl;
                buffer[1]=0;
                PosBinFi+=8;
                LongeurCode=b.LireChaineBinaire(PosBinFi,PosBinFi+Longeur);//cout<<b.ChaineBits<<" "<<LongeurCode<<endl;
                PosBinFi+=Longeur; 
                b.LireChaineBinaire(PosBinFi,PosBinFi+LongeurCode);//cout<<b.ChaineBits<<endl;
                PosBinFi+=LongeurCode;
                GenetiqueExt[b.ChaineBits]=buffer[0];cout<<y<<" "<<b.ChaineBits<<" "<<buffer[0]<<endl;
            }
            /*      fin de lecture de convention      */
        }
        b.Fermer();
        cout<<"MAP"<<endl;
        AfficheMap(GenetiqueExt);

je vai essayer en map<char,string>.
Stany

Maintenant avec map<char,string>.

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
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
 
0 01100
 
1 01110
2 0
3 00111100 !
4 0000000 '
5 0000110 ,
6 0111000 .
7 00000110 ?
8 0111100 A
9 00110000 B
10 00110110 C
11 00111110 G
12 00011000 H
13 000110 I
14 01100000 N
15 01100110 O
16 00111000 S
17 00001100 T
18 00001110 W
19 00011110 Y
20 0000 a
21 0111110 b
22 0011110 c
23 001110 d
24 000 e
25 0110000 f
26 0001110 g
27 001100 h
28 011100 i
29 00011100 j
30 0110110 k
31 011110 l
32 000000 m
33 0110 n
34 00000 o
35 00000000 p
36 011000 r
37 00110 s
38 00 t
39 0001100 u
40 01101100 v
41 0011100 w
42 0011000 y
MAP
 
:01100
:01110
 :0
!:00111100
':0000000
,:0000110
.:0111000
?:00000110
A:0111100
B:00110000
C:00110110
G:00111110
H:00011000
I:000110
N:01100000
O:01100110
S:00111000
T:00001100
W:00001110
Y:00011110
a:0000
b:0111110
c:0011110
d:001110
e:000
f:0110000
g:0001110
h:001100
i:011100
j:00011100
k:0110110
l:011110
m:000000
n:0110
o:00000
p:00000000
r:011000
s:00110
t:00
u:0001100
v:01101100
w:0011100
y:0011000

Donc avec la même boucle !!