j'ai changé mon code !
et quand je lance mon prog il y a que 0000Code:
1
2
3
4
5
6
7
8
9
10
11 void dump(unsigned char t[], int nb) { int i; printf("0000"); for(i=0;i<15;i++) { printf("%h",t[i]) nb++; } printf("\n"); }
Version imprimable
j'ai changé mon code !
et quand je lance mon prog il y a que 0000Code:
1
2
3
4
5
6
7
8
9
10
11 void dump(unsigned char t[], int nb) { int i; printf("0000"); for(i=0;i<15;i++) { printf("%h",t[i]) nb++; } printf("\n"); }
Au-moins tu commences à comprendre l'utilité des fonctions. Toutefois à quoi sert d'incrémeter "nb" si tu ne l'utilises pas ??? (accessoirement même si tu ne l'incrémentais pas je demanderais quand-même à quoi il sert...)
Ben ça dépend surtout de ce que tu passes à ta fonction dump(). Si tu lui passes par exemple un tableau vide, sa boucle ne se fera pas...
Il y a de l'effort.
Ok, "nb" est le nombre d'octets du tableau. Donc "nb" correspond à une limite et ne peut absolument pas servir pour afficher un compteur.
Si par exemple je veux compter jusqu'à "N", je ne pourrai absolument pas utiliser "N" à la fois comme limite de mon compteur et à la fois comme compteur lui-même.
Te faut une autre variable "v" qui compte de 0 jusqu'à "nb" et là tu affiches t[v] (j'utilise "v" comme nom symbolique donc toi tu peux utiliser le nom que tu veux). Essaye déjà comme ça. Pour l'affichage par 16 ça viendra ensuite.
Attention, il y a toutefois un détail que je ne maitrise pas: comment toi tu vois l'utilisation de ta fonction. Est-ce que
- tu veux d'abord tout stocker les 3000 octets de ton fichier dans un tableau et appeler dump() pour les afficher en une fois
- tu préfères lire 16 octets et appeler dump() pour les afficher, puis lire les 16 octets suivants et rappeler de nouveau dump() et etc jusqu'à la fin du fichier
Les deux solutions sont possibles, ont toutes deux des avantages et des inconvénients. Mais la programmation dans les deux cas n'est pas la même. Donc c'est à toi de réfléchir et faire un choix.
En gros je fait un do while
Je veux afficher le contenu d'un tableau d'octet, donc 16 octets par lignes et que chaque ligne commence par le numéro du premier octet de la ligne mais en décimal !
et Nb me permet de connaitre le nombre d'octet du tableau
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15 void dump(unsigned char t[], int nb) { do { int i,v; printf("0000"); for(i=0;i<15;i++) { printf("%h",t[v]) } printf("\n"); } while(i=16)
v++ me fait penser à nb[/CODE]Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16 void dump(unsigned char t[], int nb) { do { int i,v; v=0; printf("0000"); for(i=0;i<15;i++) { printf("%h",t[v]) v = v+1; //v++ } printf("\n"); } while(v=16)
Oui, je sais. C'est le but à atteindre et c'est déjà expliqué au début du topic
Ce que je te dis, c'est que tu as deux façons d'atteindre ce but
- tu lis tous les octets du fichier que tu stockes dans un tableau d'octets. Ensuite, une fois le fichier complètement lu, tu appelles ta fonction qui se charge d'afficher tous les octets ligne par ligne
- tu lis 16 octets du fichier puis tu les envoie à ta fonction qui se charge de les afficher sur une ligne. Puis tu lis les 16 octets suivants que tu envoies de nouveau à ta fonction qui les affiche sur une seconde ligne. Et etc jusqu'à la fin du fichier
Les deux façons de faire sont possibles mais le code de la fonction ne sera pas le même dans un cas ou dans l'autre. Dans le premier cas il te faut un tableau d'octets de la taille du fichier (auras-tu assez de mémoire ? comment fais-tu pour connaitre la taille nécessaire à l'avance ?) alors que dans l'autre, un tableau de 16 octets suffit.
Pourquoi cette boucle sur "i" variant de 0 à 15 que tu n'utilises pas ? Pourquoi deux boucles imbriquées alors que je t'ai déjà dit qu'une suffisait ? Si tu déroules ce code avec un papier et un crayon pour écrire ce que le code est sensé écrire qu'obtiens-tu ? Que représente dans ton esprit la première boucle ? Et la seconde ? As-tu remarqué qu'écrire while (v=16) c'était une affectation et non une comparaison et que cette affectation était toujours vraie ???
je pensais le do while me permettrai de faire cette boucle jusqu'à que j'arrive à 16
et c'est ta première idée que je veux
le problème avec ce code :
est que mon compilateur gcc ne le comprends pasCode:
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 int main() { int file; file = open(fileName,O_BINARY|O_RDONLY); if ( file < 0 ) { // failure return ( __LINE__ ); } do { size = read ( file, data, 16 ); for ( int i = 0; i < size; i++ ) { printf ( "%02x ", data[ i ] ); } printf ( "\n" ); } while ( size==16 ); close ( file ); }
si je reprends :
il faudrait que je rajoute un compteur pour nb ?Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15 void dump(unsigned char t[], int nb) { do { int i,v; printf("0000"); for(i=0;i<15;i++) { printf("%h",t[v]) } printf("\n"); } while(i=16)
pour l'instant j'ai ça
Pièce jointe 423843
Et toi, est-ce que tu le comprends ce code ? Parce que parler de "fileName", de "data" ou de "size" sans avoir défini de quoi il s'agissait...
Pfff tu me lamentes tellement tu pannes que dalle à que dalle. Parce que que ce soit en C ou en SDL ou en n'importe quel langage ; le principe est toujours le même: pour afficher un tableau d'octets, il suffit de boucler sur le tableau d'octets et d'afficher les octets.
Mouais. Ce serait bien si tu indiquais comment tu appelles ta fonction. Très certainement (et je l'ai déjà dit) avec un tableau vide...Code:
1
2
3
4
5 void dump(unsigned char t[], int nb) { int i; for (i=0; i < nb; i++) printf("%h ", t[i]); }
Je l'ai indiqué au dessus comment j appeler la fonction
fonction :Code:
1
2
3
4
5
6
7 int main() { unsigned char toto[48]={0x00,0x01,0x02,0x03,0xFF,0xFE,0xFD,0x00}; int bn; bn=48; dump(toto,bn); }
Pièce jointe 423965Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16 void dump(unsigned char t[], int nb) { int i,j; j=0; printf("0000"); for(i=0;i<nb;i++) { printf("%02x",t[i]); if(j==15) { printf("\n"); printf("%04d",j); } } printf("\n"); }
voilà le résultat que j'éxécute
Hello,
Où incrémentes-tu j ?
Et tu devrais mettre un espace dans le format de tes printf(): printf("0000 "); etc....
Merci à tous mais j'ai réussi c'est bon aprs 48h de recherche
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 void dump(unsigned char t[], int nb) { int i,compteur,k; i = 0; compteur = 0; k = 0; nb = 51; printf("%04d ",i); for(i=0;i<nb;i++) { printf("%02x ",t[i]); if(k==15) { printf("\n"); compteur = compteur+16; printf("%04d ",compteur); k = 0; } k++; } } int main() { unsigned char toto[51]={0x00,0x01,0x02,0x03,0xFF,0xFE,0xFD,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xFF,0xFA}; int bn; bn=51; dump(toto,bn); }
j'ai juste un soucis d'octet ;)
Pièce jointe 424100
- compteur et k sont superflues
- opérateur modulo
- nb est réassignée arbitraitement à 51 dans la fonction :weird: