Lecture fichier + inversion endiannes

Version imprimable

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

Bonsoir j'ai un petit soucis
je n'arrive pas à lire un fichier binaire avec des mots de 32bits

ensuite j'aimerai mettre la valeur trouvé en haxa dans la variable "Valeur1" et ensuite faire l'inversion d'andianne

voici ce que j'ai fais (après un prog de test l'inversion fonctionnerait)

mon main:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
int main (void)
{
  int Valeur1;
  int Valeur2;
  int caracterActuel=0;
  char *ptr,*ptr1;
  ptr = (char*) &Valeur1;
 
  Valeur1 = Fichier (caracterActuel);
  printf("Apres inversion Valeur = %X%X%X%X\n", ptr[0], ptr[1], ptr[2], ptr[3]);
  Valeur2 = Convert_Endianess(Valeur1);
  ptr1 = (char*) &Valeur2;
  printf("apres une nouvelle inversion Valeur = %X%X%X.%X\n", ptr1[0], ptr1[1], ptr1[2], ptr1[3]);
 
 
  return 0;
}

mon .h :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
 
// ---------- BIBLIOTHEQUE ------------- //
#include <stdio.h>
#include <stdlib.h>
 
 
// ---------- DECLARATION --------------//
 
#define DECALAGE_1OCTET		8
#define DECALAGE_2OCTETS	16
#define DECALAGE_3OCTETS	24
#define VALEUR_CHOISIE		0x12345678
#define TAILLE_MAX			100
 
 
// ----------- DECLARATION SOUS-PROG--------//
 
int Convert_Endianess(int valeur);
int Fichier (int caracterActuel);

mon sous prog ouverture fichier :

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
 
#include "stdafx.h"
#include "thales.h"
#include <stdio.h>
#include <stdlib.h>
 
int Fichier (int caracterActuel)
{
 
	caracterActuel=0;
   FILE* fichier;
   fichier = fopen("File1.b0p", "r");
 
  if (fichier != NULL)
	{
	 caracterActuel = fgetc(fichier); // On initialise caractereActuel
 
	// Boucle de lecture des caractères un à un
 	while (caracterActuel != EOF) // On continue tant que fgetc n'a pas retourné EOF (fin de fichier)
		{
	    printf("Valeur 1 = %d\n", caracterActuel); // On affiche le caractère stocké dans caractereActuel
  	    caracterActuel = fgetc(fichier); // On lit le caractère suivant
		}
 
	}
 
  else
 
	{
 
	 	  printf("Le fichier ne peux pas s'ouvrir\n");
 
	 }
 
	fclose(fichier);
 
 
  return caracterActuel;
}

et enfin mon sous prog inversion andian

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
#include "stdafx.h"
 
#include "thales.h"
 
int Convert_Endianess(int valeur)
{
int Octet1, Octet2, Octet3, Octet4;
Octet1 = (valeur & 0x000000FF);
Octet2 = (valeur & 0x0000FF00) >> DECALAGE_1OCTET ;
Octet3 = (valeur & 0x00FF0000) >> DECALAGE_2OCTETS ;
Octet4 = (valeur & 0xFF000000) >> DECALAGE_3OCTETS ;
return((Octet1 <<24) | (Octet2 <<16) | (Octet3 <<8) | (Octet4));
}

Je vous mets également ce qui vous permettra de compilé sur VS 6

StdAfx.cpp :

Code:

1
2
3
4
5
6
7
8
9
 
// stdafx.cpp : source file that includes just the standard includes
//	thales.pch will be the pre-compiled header
//	stdafx.obj will contain the pre-compiled type information
 
#include "stdafx.h"
 
// TODO: reference any additional headers you need in STDAFX.H
// and not in this file

ainsi que le point h

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
// stdafx.h : include file for standard system include files,
//  or project specific include files that are used frequently, but
//      are changed infrequently
//
 
#if !defined(AFX_STDAFX_H__AFCF6C05_596A_4658_B79B_A50618CD6ED6__INCLUDED_)
#define AFX_STDAFX_H__AFCF6C05_596A_4658_B79B_A50618CD6ED6__INCLUDED_
 
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
 
 
// TODO: reference additional headers your program requires here
 
//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
 
#endif // !defined(AFX_STDAFX_H__AFCF6C05_596A_4658_B79B_A50618CD6ED6__INCLUDED_)

Voilà merci de m'aider donc enfaite pour résumé je n'arrive pas à lire un fichier binaire avec des mots de 32 bits et mettre la lecture dans "int Valeur1"

je vous fournis un programme qui compile mais qui n'affiche pas ce que je demande en gros il lit mal et j'aimerai que la lecture soit convertit en hexa et mise dans la variable "int variable 1"

voilà merci de m'aider
bonne soirée

Loïc

a la lecture de ton programme j'ai pas vraiment compris ce que tu veux faire car ca a l'aire different de ce que tu pretents vouloir.
j'ai pas lut conversion mais la fonction fichier pose probleme.
Code:

1 2 3 4 5 int Fichier (int caracterActuel) { caracterActuel=0; }
1/ probleme moindre mais probleme quand meme a longterme. pourquoi initialiser caracterActuel a 0 si ca valeur est sense venir a l'appel? ou inversement a quoi ca set de faire passer un argument a une fonction si cet argument n'est jamais utilise?
oubien tu vire le caracterActuel=0 ou alors tu fait

Code:

int Fichier()

2/ta boucle ne fait qu'afficher le contenu du fichier. et renvois EOF. je m'expique:
imagine un fichier avec 3 caracter ABC donc ta boucle affiche

Citation:

Valeur 1 =A
Valeur 1=B
valeur 1=C

puis a la fin retourn la dernier valeur de caracterActuel qui est EOF.
puis tu fois quoi? ben tu dit a un pointeur sur UN char de lire un tableau de QUATRE char. tu vas droit vers un segfault.
donc j'ai meme pas regarde le reste.
ce que je te conseille, c'est
1/ recrire ta fonction fichier de sorte qu'elle te renvois un pointeur sur char qui contient le contenue ENTIER du fichier et tu affiches le resultat a l'ecrant.

Code:

char *Fichier()

ou 2/ ecrire la meme fonction mais qui ne renvois qu'un caractere a la fois et la position dans le fichier est memorise.
Code:

1 2 3 4 5 6 7 8 9 10 11 int Fichier() { int caractereActuel static unsigned char positionActuelle=0; fopen(); fseek(fichier,positionActuelle,SEEK_SET); ... ... ++positionActuelle; return caracterActuel; }
bon dans le cas 2 tu vois qu'on ouvre et ferme le fichier trop souvent ca peut etre lent, mais tu peux declarer le fichier de sorte que tu n'ai a l'ouvire qu'une seule fois. dans le cas 2 toujours tu vas faire une boucle qui appelle Fichier le nombre de fois qu'il faudra et le resutat sera justement stoque dans un tableau
Code:

1 2 3 int tbl[1000] for(i=0;i<1000;++i) tbl[i]=Fichier();
tandis que dans le cas un tu auras:
Code:

1 2 3 char *tbl=Fichier(); printf("contenus du fichier est :%s\n",tbl); free(tbl);
bref

Citation:

Envoyé par lilington

1/ recrire ta fonction fichier de sorte qu'elle te renvois un pointeur sur char qui contient le contenue ENTIER du fichier et tu affiches le resultat a l'ecrant. j'ai pas tout à fait compri

est ce que c'est ça?
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 char *Fichier() { int Valeur1; FILE* fichier; fichier = fopen("File1.b0p", "r"); if (fichier != NULL) { // Il faut mettre quoi ici? fread? } else { printf("Le fichier ne peux pas s'ouvrir\n"); } fclose(fichier); return Valeur1;
Ceci ets donc dans le main
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 int main (void) { int Valeur1; int Valeur2; int tb1 [TAILLE_MAX]; char *ptr,*ptr1; ptr = (char*) &Valeur1; char *tbl=Fichier(); printf("contenus du fichier est :%s\n",tbl); free(tbl); printf("Apres inversion Valeur = %X%X%X%X\n", ptr[0], ptr[1], ptr[2], ptr[3]); Valeur2 = Convert_Endianess(Valeur1); ptr1 = (char*) &Valeur2; printf("apres une nouvelle inversion Valeur = %X%X%X.%X\n", ptr1[0], ptr1[1], ptr1[2], ptr1[3]); return 0; }
merci beaucoup pour l'aide que tu m'apportes à vrai dire c'est la première fois que je fait ce type de prog avec des fichiers.

en revoyant ton main je vois que tu n'as pas du tout compris l'utiliter de charger le tout dans un pointeur vu que tu ne l'utilise meme pas. on reprend par le main:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 int main (int argc,char **argv) { char *valeur1=NULL; valeur1=Fichier(TAILLEMAX); if(valeur1==NULL) { puts("chargement du fichier a echoue ou allocation erreur"); return 0; } printf("voici le contenu du fichier non inverse: %s\n",valeur1); valeur2=Convert_Endianess(valeur1); if(valeur2==NULL) { puts("allocation erreur"); return 0; } printf("voici les valeurs inversees : %s\n",valeur2); free(valeur2); free(valeur1); return 0; }
bon tu vois que ta fonction Convert_Endianess va devoir etre modifie aussi.
je vais t'aider pour Fichier mais tu te debrouille pour Convert_Endianess si tu n'y arrives pas c'est que tu as autre chose a apprendre en route.
on y va
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 char * Fichier(int MAX) { char *result=NULL; char buffer[BUFFER_SIZE]; //defini toi meme buffer_size FILE *fichier=fopen("File1.b0p", "r"); if (fichier != NULL) return NULL; //on suppose que MAX est suffisement grand pour contenir tout ton fichier. //si non tu devras faire des realloc mais je suppose que tu n'est pas prets? result=malloc(sizeof(char)*MAX+1); if (result==NULL) return result; memset(result,0,MAX); // a cause de strcat while(le_fichier_n_est_pas_fini) { fread(buffer,BUFFER_SIZE,sizeof(char),fichier); strcat(result,buffer); } fclose(fichier); return result; }
donc ici on alloue un pointeur de taille suffisante pour faire tenir ton fichier a l'interrieur, puis on lit BUFFER_SIZE elements du fichier quand stocke dans buffer.
apres on concatene avec result.donc maintenant result contient tout ton fichier.
quand on sort de la fonction c'est ou NULL ou le contenue du fichier.
tu as compris? si oui modifies toi meme la fonction de conversion. je te donne le prototype:

Code:

char *Convert_endianless(const char *valeurs);

si je comprends bien il faut que je face un : malloc ?

mais au niveau des décalage je doit bien laissé comme c'est, après bien sur il faut retourné

valeurs
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 #include "thales.h" char *Convert_Endianess(const char *valeurs) { *valeurs = NULL; valeurs=malloc(sizeof valeurs+1); int Octet1, Octet2, Octet3, Octet4; Octet1 = (valeurs & 0x000000FF); Octet2 = (valeurs & 0x0000FF00) >> DECALAGE_1OCTET ; Octet3 = (valeurs & 0x00FF0000) >> DECALAGE_2OCTETS ; Octet4 = (valeurs & 0xFF000000) >> DECALAGE_3OCTETS ; valeurs = (Octet1 << DECALAGE_3OCTETS) | (Octet2 << DECALAGE_2OCTETS ;) | (Octet3 << DECALAGE_1OCTET) | (Octet4) return valeurs; }
enfaite avec malloc tu as réservé plus ou moins de place suivant la taille du mot c'est ça?

avec malloc j'ai copier tout ton fichier en memoire si ton fichier etait
ABCDEF
tu as maintenant en memoire
[A] [B] [C] [D] [E] [F] [\0]avec [A] a 0 et [F] a 5
donc dans le main valeur1[0]='A' et valeur1[1]='B' et ainsi de suite strcat met pour toi le '\0' a la fin.

donc dans ta fonction convert tu n'as qua directement lire valeur1

Citation:

char *Convert_Endianess(const char *valeurs)
{
*valeurs = NULL;
valeurs=malloc(sizeof valeurs+1);

NON NON et NON c'est pas du tout ca.
faut faire un tour sur le site et lire les tutos sur les pointeurs pour plus de details ce que tu as fait la va droit dans le mur.
bon j'avais pas du tout lu le code de convert mais la je vois que tu dois seulement retourner un int.
et vu le contenu de ta fonction on suppose aussi que ton fichier ne contient que 4 octets sinon...bref
voila un exemple de ce que tu peux faire:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 int Conver_Endianess(const char *valeurs) { int result=0; /*int i; */ valeurs[0] = (valeurs[0] & 0x000000FF); valeurs[1] = (valeurs[1] & 0x0000FF00) >> DECALAGE_1OCTET ; valeurs[2] = (valeurs[2] & 0x00FF0000) >> DECALAGE_2OCTETS ; valeurs[3] = (valeurs[3] & 0xFF000000) >> DECALAGE_3OCTETS ; result=(valeurs[0] << DECALAGE_3OCTETS) | (valeurs[1] << DECALAGE_2OCTETS ;) | (valeurs[2] << DECALAGE_1OCTET) | valeurs[3]); return result; }
mais comme je l'ai dit sa suppose que ton fichier n'a que 4 octets sinon le reste est perdu de toute facon.
si tu as envis de plus, tu modifies la fonction Fichier pour qu'elle ne lise que 4 octets a la fois et momorise la position dans le fichier pour continuer la prochaine fois que tu l'appelleras.

27/09/2011, 12h42
diogene
Citation:
voila un exemple de ce que tu peux faire:

Code:

1 2 3 4 5 6 int Conver_Endianess(const char *valeurs) { int result=0; /*int i; */ valeurs[0] =.....
Non, on ne peut pas modifier les éléments de valeurs puisque c'est un pointeur sur des char constants

voici mon changement andian mais impossible de compiler j'ai des erreur

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
 
#include "thales.h"
#define DECALAGE_1OCTET		8
#define DECALAGE_2OCTETS	16
#define DECALAGE_3OCTETS	24
 
int Convert_Endianess(const char *valeurs)
{
     int result=0;
     /*int i;
     */
     valeurs[0] = (valeurs[0] & 0x000000FF);
     valeurs[1] = (valeurs[1] & 0x0000FF00) >> DECALAGE_1OCTET ;
     valeurs[2] = (valeurs[2] & 0x00FF0000) >> DECALAGE_2OCTETS ;
     valeurs[3] = (valeurs[3] & 0xFF000000) >> DECALAGE_3OCTETS ;
     result=((valeurs[0] << DECALAGE_3OCTETS) | (valeurs[1] << DECALAGE_2OCTETS) | (valeurs[2] << DECALAGE_1OCTET) | (valeurs[3]));
     return result;
}

voici les lignes d'erreur/ligne:

Code:

1
2
3
4
5
 
    valeurs[0] = (valeurs[0] & 0x000000FF);
     valeurs[1] = (valeurs[1] & 0x0000FF00) >> DECALAGE_1OCTET ;
     valeurs[2] = (valeurs[2] & 0x00FF0000) >> DECALAGE_2OCTETS ;
     valeurs[3] = (valeurs[3] & 0xFF000000) >> DECALAGE_3OCTETS ;

et sa me met
assignment of read-only location changement andian.

et pour

Code:

1
2
 
    result=((valeurs[0] << DECALAGE_3OCTETS) | (valeurs[1] << DECALAGE_2OCTETS) | (valeurs[2] << DECALAGE_1OCTET) | (valeurs[3]));

parse error before ')' token changement andian.c

je vais jamais y arrivé je sens :(

Tu cherches à faire deux choses à la fois, c'est ça ton problème.

Utilise des fonctions plus simples:

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
int LireEntierBigEndian(char const *bytes)
{
	int ret = 0;
	int i;
	for(i=0 ; i<sizeof(int) ; i++)
	{
		ret <<= 8;
		ret |= bytes[i];
	}
	return ret;
}
 
int LireEntierLittleEndian(char const *bytes)
{
	int ret = 0;
	int i;
	for(i=0 ; i<sizeof(int) ; i++)
	{
		int valeurByte = bytes[i];
		valeurByte <<= (8*i);
		ret |= valeurByte;
	}
	return ret;
}

et en écriture:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
void EcrireEntierBigEndian(char *bytes, int entier)
{
	int i;
	for(i=0 ; i<sizeof(int) ; i++)
	{
		bytes[sizeof(int) - i - 1] = (char)( entier & 0x000000FF );
		entier >>= 8;
	}
}
 
void EcrireEntierLittleEndian(char *bytes, int entier)
{
	int i;
	for(i=0 ; i<sizeof(int) ; i++)
	{
		bytes[i] = (char)( entier & 0x000000FF );
		entier >>= 8;
	}
}

Code:

1 2 et sa me met assignment of read-only location changement andian
Voir mon message qui précède

27/09/2011, 16h35
loic072

oui mais j'ai fait comme tu m'as dit j'ai bien

variable[0] = ....

etc
27/09/2011, 18h00
lilington

effectivement quand j'avais mis const char * j'avais pas lut la fonctin convert et elle etait sense renvoyer un autre pointeur.

bon soit tu enleve le const, soit tu calcules directement le resultat que tu retourne.
vu tes problemes je te conseil d'enlever const.

Code:

int Convert_Endianess(char *valeurs)

ca resout le probleme, c'est de ma faute j'avais oublier de l'enlever quand j'ai vu que je ne devrait pas renvoyer un autre pointeur.

pour l'erreur sur le parse, je vois pas du tout a moiins que tu aies mis un ';' a un de tes defines. fais voir tes declarations pour tes constantes DECALAGE
27/09/2011, 20h13
loic072
sur le compilateur de chez moi il me met que memset n'est pas déclaré tout comme strcat alors que j'ai mis la biblio stdio et stdlib.

Cependant pour la fonction free(), si je retourne un entier après ma conversion cela ne fonctionne pas car j'ai :
Code:

1 2 int Convert_Endianess(char *valeurs)
et
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 int valeur2; . . . . . valeur2 = Convert_Endianess(valeur1); . . . . free(valeur2);
28/09/2011, 02h16
lilington

je ne te l'ai pas dis car pour moi c'etait evident mais tu ne peux pas faire free(valeurs2) dans le main etant donnee que valeur2 n'est pas un pointeur.
je pense vraissemblablement que comme la dit Medinoc tu vas un peu vite en besogne et tu essaies de faire trop de chose en meme temps.
je te conseilles de faire comme il t'a dit.

sinon memset est dans string.h il faut faire

Code:

#include <string.h>

si c'est la seule erreur ca devrait marcher mais...
28/09/2011, 20h17
loic072

voilà j'ai tout modifié il compile bien mais à l'execusion l'exe me fait planté windows, cela peut venir d'où? après j'ai juste la console m'affichant "appuyer sur une touche"

Bonsoir,

Pourquoi lire le fichier binaire octets par octets alors qu'il serait plus simple de le lire par mots de 32 bits ?

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
#include <stdio.h>     // fopen()
#include <stdlib.h>    // EXIT_FAILURE/SUCCESS
#include <stdint.h>    // pour uint32_t
#if defined(_MSDOS) || defined(_WIN32) || defined(__CYGWIN32__) || defined(__CYGWIN__)
  #include <intrin.h>
#endif
int main(int argc, char *argv[])
{
    FILE *handler = NULL ;
    char *filename = "File1.b0p" ;
 
    uint32_t readValue = 0L ;
 
    // Ouverture du fichier
    if((handler=fopen(filename, "r"))==NULL) {
        printf("Erreur d'ouverture du fichier %s\n", filename) ;
        return EXIT_FAILURE ;
    }
 
    // Jusqu'à la fin du fichier ...
    while(!feof(handler))
        // ... lire par mot de 32 bits
        if(fread(&readValue, sizeof(uint32_t), 1, handler)==1)
            // et modifier son endianess
#if defined(_MSDOS) || defined(_WIN32) || defined(__CYGWIN32__) || defined(__CYGWIN__)
            printf("Endianness(%.8Xh) %.8Xh\n", readValue, _byteswap_ulong(readValue)) ;
#else
            printf("Endianness(%.8Xh) %.8Xh\n", readValue, __builtin_bswap32(readValue)) ;
#endif
 
    // Fermeture du fichier
    fclose(handler) ;
 
    return EXIT_SUCCESS ;
}

[Edit]
La fonction __builtin_bswap32(int32_t x) est définie par GCC. Pour Visual C++ il faut utiliser la fonction _byteswap_ulong(unsigned long arg1) en incluant intrin.h.
PS: Je ne peu pas testé la version sous Windows.

29/09/2011, 04h12
lilington

Oui moi aussi je peux pas tester j'ai pas windows.
tu as un debugeur?
bon plus simplement fait voir le main.
29/09/2011, 04h14
lilington

Citation:

Envoyé par Elijha

Bonsoir,

Pourquoi lire le fichier binaire octets par octets alors qu'il serait plus simple de le lire par mots de 32 bits ?.

parceque pour lui c'est plus simple de lire octet par octet plus tard s'il veut/peut il fera comme tu dis. Enfin je me souvient qu'avant je lisait toujours octet par octet, ca m'a permit de comprendre
29/09/2011, 09h54
Médinoc
Citation:

Pourquoi lire le fichier binaire octets par octets alors qu'il serait plus simple de le lire par mots de 32 bits ?

Parce qu'on cherche à s'abstraire de l'endianness de la machine, j'ai l'impression.

Avec ton code, le comportement diffère selon l'endianness de la machine:
- Sur une machine big-endian, fichier big-endian: Le nombre avant inversion est correct, le nombre après inversion est inversé.
- Sur une machine big-endian, fichier little-endian: Le nombre avant inversion est inversé, le nombre après inversion est correct.
- Sur une machine little-endian, fichier big-endian: Le nombre avant inversion est inversé, le nombre après inversion est correct.
- Sur une machine little-endian, fichier little-endian: Le nombre avant inversion est correct, le nombre après inversion est inversé.
Bien sûr, si tout ce qu'on veut est vraiment "inverser l'endianness du fichier" en refaisant un fwrite() juste après, ça ne change rien. Mais si on veut traiter les valeurs, ça devient important.

En revanche, avec du code indépendant de l'endianness de la machine, on peut avoir le nombre systématiquement correct quelle que soit l'endianness du fichier, du moment que celle-ci est connue.

bonjour, voici mon code entier

le main :

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
 
// thales.cpp : Defines the entry point for the console application.
//
#include "stdafx.h"
 
#include "thales.h"
 
 
 
int main (int argc,char **argv)
{
     int valeur2;
	 char *valeur1=NULL;
     valeur1=Fichier(TAILLE_MAX);
     if(valeur1==NULL)
     {
          puts("chargement du fichier a echoue ou allocation erreur");
          return 0;
     }
     printf("voici le contenu du fichier non inverse: %s\n",valeur1);
 
	 EcrireEntierLittleEndian(valeur1, valeur2);
 
	 if(valeur2==NULL)
     {
          puts("allocation erreur");
          return 0;
     }
     printf("voici les valeurs inversees : %s\n",valeur2);
    return 0;
}

le .h

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
 
// ---------- BIBLIOTHEQUE ------------- //
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
 
 
// ---------- DECLARATION --------------//
 
#define DECALAGE_1OCTET		8
#define DECALAGE_2OCTETS	16
#define DECALAGE_3OCTETS	24
#define VALEUR_CHOISIE		0x12345678
#define TAILLE_MAX			1025
#define BUFFER_SIZE			1025
 
 
// ----------- DECLARATION SOUS-PROG--------//
 
//int EcrireEntierBigEndian(char *valeurs, int entier);
void EcrireEntierLittleEndian(char *valeurs, int entier);
 
 
char * Fichier(int MAX);

le traitement fichier

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
 
#include "stdafx.h"
#include "thales.h"
 
 
char * Fichier(int Max)
{
    char *result=NULL;
    char buffer[BUFFER_SIZE];   
 
    FILE *fichier=fopen("File1.b0p", "r"); 
 
    if (fichier != NULL)
	{
		   while(!feof(fichier))
		{
          fread(buffer,BUFFER_SIZE,sizeof(char),fichier);
          strcat(result,buffer);
		}
 
	}
 
	else
	{
		printf("fichier non existant\n");
	}
	memset(result,0,Max);
 
 
 
	fclose(fichier);
    return result;
}

le changement andian :

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 "stdafx.h"
 
#include "thales.h"
#include <stdio.h>
#include <stdlib.h>
 
 
 
/*void EcrireEntierBigEndian(char *valeurs, int entier)
{
	int i;
	for(i=0 ; i<sizeof(int) ; i++)
	{
		bytes[sizeof(int) - i - 1] = (char)( entier & 0x000000FF );
		entier >>= 8;
	}
} */
 
void EcrireEntierLittleEndian(char *bytes, int entier)
{
	int i;
	for(i=0 ; i<sizeof(int) ; i++)
	{
		bytes[i] = (char)( entier & 0x000000FF );
		entier >>= 8;
	}
}

pouvez vous me dire si le prog fonctionne chez vous?

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