Stockage séquence C

Version imprimable

Voir 40 message(s) de cette discussion en une page

Je ne suis pas sûr t'avoir bien compris ton problème.
Tu as donc un fichier texte. Il contient des données écrites en binaires (sous forme de caractères), chaque donnée étant codée sur x_bits. Les données sont des entiers non signés (apparemment).

Tes données sont codées sur x_bits et il te faut un entier de taille suffisante pour stocker la valeur d'un entier de x_bits. Un unsigned int ne garantit que 16 bits donc x_bits doit alors être inférieur ou égal à 16. Si tu as besoin de plus, utilise un unsigned long qui te garantit 32 bits.

La taille du tableau qui stocke les caractères du fichier avant conversion doit être en correspondance (+1 pour le zéro terminal)
La conversion doit être effectuée par strtoul, puisque tes données sont non signées.

Une trame possible :
Code:

1 2 3 4 5 6 7 8 9 10 unsigned long read_bits_sequence(FILE* dat,unsigned int x_bits) { ... // Vérifier que x_bits <=32 unsigned long seq; char sequence[33]; // Et non pas char * sequence[] et non pas const puisqu'on veut mettre des choses dedans .... // Lecture de x_bits chars. Attention à la fin de fichier ? sequence[x_bits]=0; // Le zéro terminal seq=strtoul(sequence, NULL, 2); return seq; }

Citation:

Envoyé par DelilahHinxs

C'est ca que j'ai avec hexedit...je poste un lien vers mon fichier de suite

OK. C'est donc un fichier de caractères '0' ou '1. Il n'est pas organisé en lignes, mais en une seule séquence. La longueur de 165 caractères (non multiple de 8) est fixe ou elle peut être plus grande ?

Voila un exemple qui extrait les caractères, les transforme en valeurs numériques et les stocke par groupe de 8 bits dans un tableau. Je considère que le MSB est en tête. Ensuite, je fais un affichage en hexadécimal :

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
 
#include <stdio.h>
 
/* 0 | 1 */
#define DBG 0
 
#define FNAME "data_in.txt"
 
int main (void)
{
   FILE *fp = fopen (FNAME, "r");
   if (fp != NULL)
   {
      unsigned char tab[(165 / 8) + 1];
      size_t i_bit = 0;
      size_t i_oct = 0;
      unsigned oct = 0;
      int c;
 
      while ((c = fgetc (fp)) != EOF && i_oct < sizeof tab)
      {
         unsigned bit = c - '0';
#if DBG
         printf ("%u:", bit);
#endif
         oct |= (bit << i_bit);
 
#if DBG
         printf (" %02X\n", oct);
#endif
 
         i_bit++;
         if (i_bit == 8)
         {
            i_bit = 0;
            tab[i_oct] = oct;
            i_oct++;
            oct = 0;
#if DBG
            printf ("\n");
#endif
         }
      }
#if DBG
      printf ("\n");
      printf ("\ni_bit = %u\n", i_bit);
      printf ("\ni_oct = %u\n", i_oct);
#endif
 
      {
         size_t i;
         for (i = 0; i < sizeof tab; i++)
         {
            printf ("%02X ", tab[i]);
         }
         printf ("\n");
      }
   }
   else
   {
      perror (FNAME);
   }
   return 0;
}

Code:

1
2
3
4
 
55 54 FA AB 55 AD AA 55 55 A5 AA AA 4C 55 69 55 55 55 55 D5 10
 
Press ENTER to continue.

24/02/2008, 18h07
DelilahHinxs

Waw exactement ce que je voulais :D

mais je vais décoder ! parce que certaines parties me semblent obscure :)

Merci!

Citation:

Envoyé par Emmanuel Delahaye

OK. C'est donc un fichier de caractères '0' ou '1. Il n'est pas organisé en lignes, mais en une seule séquence. La longueur de 165 caractères (non multiple de 8) est fixe ou elle peut être plus grande ?

Elle peut être beaucoup plus grande...donc je pourrais introduire un paramètre pour que ces séquences soient plus grandes que 8 bits et plus longue que 165 caractères?

EDIT: Ha oui d'accord mais mais séquences comment sont elles misent dans le tableau?

Et comment alors stocker des séquences partielles des 165 par exemple des séquences de 8...je fais un tableaux pour chaque? et je fais comment pour intégrer ça dans une fonction?

Je vais travailler ma fonction directement ici , je vais faire des erreurs :D dès que vous en voyez des énormes :p dite le moi merci!
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 unsigned long read_bits_sequence(FILE* dat,size_t x_bits) { /* Variables */ unsigned char * stockage_bits; unsigned int i_bits; /* On compte le nombre de bits présents dans le fichier */ i_bits = count_nbr_bits(dat); /* Allocation Dynamique */ stockage_bits =(unsigned char*) malloc((i_bits/x_bits)+1); if(stockage_bits == NULL) { printf("Erreur allocation dynamique...\n"); } printf("Allocation memoire reussie taille du tableau : %d\n",(i_bits/x_bits)+1); /* Lecture */ /* return à faire */ }

24/02/2008, 18h33
Emmanuel Delahaye

Citation:

Envoyé par DelilahHinxs

Elle peut être beaucoup plus grande...donc je pourrais introduire un paramètre pour que ces séquences soient plus grandes que 8 bits et plus longue que 165 caractères?

Dans ce cas, il faut prévoir un mécanisme dynamique. Soit une mesure de la taille suivie de la création du tableau, soit un tableau souple que l'on agrandit selon les besoins (par doublage, par exemple), soit une liste chainée.

J'ai prévu un assemblage par groupe de 8-bit, mais on fait ce qu'on veut (max 32-bit, unsigned long, pour être portable ou 64-bit, unsigned long long, en C99)

Citation:

EDIT: Ha oui d'accord mais mais séquences comment sont elles misent dans le tableau?

Tant qu'il y a écrit <en cours ...>, c'est que je n'ai pas terminé... Je montre l'avancement de mes travaux en publiant les étapes stables du codage au fur et à mesure... C'est terminé.

Ensuite, je ne vais peut être pas écrire tout le code à ta place... Je t'ai montré le principe de base de la conversion et de l'assemblage....

Citation:

Code:

unsigned char stockage_bits[(i_bits / x_bits) + 1]; /* Alors là j'ai une erreur il me dit que la dimension est pas constante, normale ca dépend des paramètres de la fonction */

C'est pour ça qu'il faut utiliser l'allocation dynamique. Tu connais les bases du C ? Parce que ça ne s'invente pas. Le C est un langage simple, mais subtil qui demande un certain temps d'apprentissage. Tu es formé comment ?
24/02/2008, 18h46
DelilahHinxs

Citation:

Envoyé par Emmanuel Delahaye

Dans ce cas, il faut prévoir un mécanisme dynamique. Soit une mesure de la taille suivie de la création du tableau, soit un tableau souple que l'on agrandit selon les besoins (par doublage, par exemple), soit une liste chainée.

J'ai prévu un assemblage par groupe de 8-bit, mais on fait ce qu'on veut (max 32-bit, unsigned long, pour être portable ou 64-bit, unsigned long long, en C99)

Tant qu'il y a écrit <en cours ...>, c'est que je n'ai pas terminé... Je montre l'avancement de mes travaux en publiant les étapes stables du codage au fur et à mesure... C'est terminé.

Ensuite, je ne vais peut être pas écrire tout le code à ta place... Je t'ai montré le principe de base de la conversion et de l'assemblage....

C'est pour ça qu'il faut utiliser l'allocation dynamique. Tu connais les bases du C ? Parce que ça ne s'invente pas. Le C est un langage simple, mais subtil qui demande un certain temps d'apprentissage. Tu es formé comment ?

Je suis formé en fortran 90, en C il y a MALLOC en C++ new, mais je ne vois pas comment allouer mon tableaux? je fais un pointeur puis j'alloue avec x_bits , i_bits
24/02/2008, 19h13
Emmanuel Delahaye

Citation:

Envoyé par DelilahHinxs

Je suis formé en fortran 90, en C il y a MALLOC

Non. Il y a malloc().

Citation:

mais je ne vois pas comment allouer mon tableaux? je fais un pointeur puis j'alloue avec x_bits , i_bits

J'ai donné 3 pistes. La plus simple est la première :

Lire le fichier caractère par caractères
compter les caractères (N)
revenir au debut (rewind())

Pour un assemblage en groupe de 8 bits, allouer le tableau de type unsigned char d'une taille de (1 + (N/8)) éléments avec malloc().

etc.

Milles fois merci à vous !

Avec ces pistes je vais pouvoir avancer très vite et progresser en C!

J'ai réussit :)

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
unsigned long read_bits_sequence(FILE* dat,size_t x_bits)
{
	/* Variables */
	char * tmp;
	unsigned int i=0;
	long int seq=0;
	/* Allocation Dynamique */
	tmp =(char*) malloc(x_bits+1);
	if(tmp == NULL)
	{
		printf("Erreur allocation dynamique...\n");
	}
	/* Lecture */
	rewind(dat); // On revient au début du fichier
	fgets(tmp,x_bits,dat); // On lit une séquence x bits
	printf("%s\n",tmp);
	seq = strtol(tmp,NULL,10); // on convertit la séquence en long 
	printf("%d\n",seq); // On vérifie la valeur de seg 
    return seq;
}

Voir 40 message(s) de cette discussion en une page