Discussion :

[loic072]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[lilington]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
int tbl[1000]
for(i=0;i<1000;++i)
    tbl[i]=Fichier();

tandis que dans le cas un tu auras:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

bref

[loic072]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[lilington]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

char *Convert_endianless(const char *valeurs);

[loic072]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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?

[lilington]

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

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[diogene]

voila un exemple de ce que tu peux faire:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[loic072]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[Médinoc]

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

Utilise des fonctions plus simples:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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;
	}
}

[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"

[Elijha]

Bonsoir,

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[lilington]

Oui moi aussi je peux pas tester j'ai pas windows.
tu as un debugeur?
bon plus simplement fait voir le main.

[lilington]

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

[Médinoc]

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.

[loic072]

bonjour, voici mon code entier

le main :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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?

[Médinoc]

Valeur2 n'est jamais initialisé.

Tu dois faire un truc de ce genre:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
valeur2 = LireEntierBigEndian(valeur1);
EcrireEntierLittleEndian(valeur2, valeur1);

[lilington]

deja dans le main tu as un probleme.
tu affiches un int en le formattant string. bizarre que tu n'ais pas eu de warning a la compilation (je pense que VC doit le faire)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

printf("voici les valeurs inversees : %d\n",valeur2);

j'ai remplacer %s par %d.
ensuite tu as fait int valeur2, sans comme l'a dit medinoc initialiser, et apres tu fais:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

if(valuer2==NULL)

ca compile avec warning normalement tu devrait plutot tester avec 0 ou -1 ou ce que tu veux

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

if(valeur2==0)

ta fonction de conversion en faite je me demande bien ce qu'elle fait,
elle modifie le contenu du pointeur en entrer avec une valuer (entier) jamais initialiser donc qui contient du garbage. puis tu fais entier>>=8;
mais dis moi, entier etait egal a combient au debut?
et visiblement tu esperes (meme si entier avait ete initialiser) que la fonction modifie le contenu de entier?
tu as deux choix
1/

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

valeur2=EcrireEntierLittleEndian(valeur1);

2/

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

EcrireEntierLittleEndian(valeur1,&valeur2);

mais vraiment je te conseil la 1/ car sinon on va avoir d'autre probleme.
calcule tout dans ta fonction en tu renvois le resultat.

[loic072]

enfaite je suis bloqué car je sais pas comment faire

est ce bon comme ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
int EcrireEntierLittleEndian(char *bytes)
{
	int i;
	int entier;
	for(i=0 ; i<sizeof(int) ; i++)
	{
		bytes[i] = (char)(entier & 0x000000FF );
		return (entier >>= 8);
 
	}
}

merci beaucoup pour votre aide qui m'est vraiment précieuse

[lilington]

10 x NON
d'abort explique moi ce que fait reelement ta fonction
ensuite visiblement tu ne sait pas utiliser une boucle ou alors tu n'as pas ete attentif en tapant ton code.
le return si tu me mets dans la boucle comme il est la, alors ton FOR ne sert strictement a rien.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
int EcrireEntierLittleEndian(char *bytes)
{
	int i;
	int entier;
	for(i=0 ; i<sizeof(int) ; i++)
	{
		entier = bytes[i] & 0x000000FF ;
		entier >>= 8;
	}
        return entier;
}

j'ecris ca pour donner aun sens a ce que j'ai lut mais je sais pas vraiment si c'est ce que tu veux.
en suite c'est quoi cette histoire de sizeof(int).
sur ma machine int vaut 4. mais sur une autre ca peut valoir autre chose.
ne serait-il pas mieux de mettre la taille de valeurs?
bon on en reparlera si ton code marche et que la modification que j'ai apporte marche comme tu veux dans le cas particulier de ton exemple.
apres on vera.

[Médinoc]

Pourquoi la fonction "LireXxxx" (qui parse un tableau de bytes pour en extraire l'entier) s'est-elle mystérieusement renommée en "EcrireXxxx" (fonctions supposées écrire la valeur d'un entier dans un tableau de bytes) ?