Problème d'éxécution d'un fichier .exe
Utilisateur anonyme
-
Utilisateur anonyme -
Utilisateur anonyme -
Bonjour,
J'ai compilé une source en langage C que j'ai crée cependant bien que je puisse l'exécuter sur le PC où je l'ai compilé, je ne peut pas l'exécuter sur d'autres ordinateurs et j'ignore pourquoi.
Tous les ordi en question sont sur Windows XP.
Lorsque je lance le fichier .exe sur un autre pc, il met le message:
Le système ne peut pas exécuter le programme spécifié.
Si quelqu'un à une solution...
Merci d'avance
J'ai compilé une source en langage C que j'ai crée cependant bien que je puisse l'exécuter sur le PC où je l'ai compilé, je ne peut pas l'exécuter sur d'autres ordinateurs et j'ignore pourquoi.
Tous les ordi en question sont sur Windows XP.
Lorsque je lance le fichier .exe sur un autre pc, il met le message:
Le système ne peut pas exécuter le programme spécifié.
Si quelqu'un à une solution...
Merci d'avance
A voir également:
- Problème d'éxécution d'un fichier .exe
- Fichier bin - Guide
- Comment ouvrir un fichier epub ? - Guide
- Comment réduire la taille d'un fichier - Guide
- Fichier rar - Guide
- Fichier .dat - Guide
3 réponses
tu as tres surement des erreur dans ton code ce qui produit un "faux" .exe. montre ton code et on pourra peu etre t'aider
Voici mon code intégral (en deux fichiers + 1 txt)
Il s'agit d'un programme de conversion alphabétique / Morse. C'est un DM que je dois faire pour mon iut.
Le prog fonctionne nickel sur le pc où je compile.
Il y a un fichier .h où j'y ai mis des fonctions basiques gérant des listes chaînées
un fichier .cpp où j'y ai mis les fonctions plus complexes liée à la conversion + le main
un fichier .txt où j'y ai mis un alphabet morse
Le prog lis le fichier .txt et enregistre l'alphabet morse dans une liste chaînée où il y a un caractère (le caractère alphabétique), une chaine de caractères (l'équivalent en morse) et un pointeur sur un autre élément de la chaîne.
Ensuite, il lis un fichier alphabétique et compare chaque caractères du fichier avec la liste chaînée, le trouve dans cette liste, récupère le code correspondant et l'inscrit dans un autre fichier.
(Mon prog peut faire l'inverse également)
Note: le fichier texte avec l'alphabet Morse doit se trouver dans le même répertoire que l'exécutable
par contre, il faut mettre le fichier source et le fichier destination (dans cette ordre) en paramètre lors de l'exécution du programme.
Fichier liste.h
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define LIGNE_MAX 256;
#define CODE_MAX 10;
typedef int booleen;
struct element{
char caractere;
char code[10];
struct element *suiv;
};
typedef struct element Element;
typedef struct element* Alphabet;
booleen estVide(Alphabet A)
{
return (A==NULL);
}
char rec_carac(Alphabet A)
{
return A->caractere;
}
char *rec_code(Alphabet A)
{
return A->code;
}
Alphabet reste(Alphabet A)
{
return A->suiv;
}
Alphabet cons(char ca, char *co, Alphabet A)
{
Alphabet p;
p=(Alphabet)malloc(sizeof(Element));
p->caractere=ca;
strcpy(p->code,co);
p->suiv=A;
return p;
}
fichier Morse1.2.cpp
#include "Liste.h"
#include <stdlib.h>
//******************************************************************************************************************
//***********************************************Fonction imp_carac*************************************************
//******************************************************************************************************************
//***************Vérifie et valide la chaîne de caractères. Remplace les minuscules par des majuscules**************
//******************************************************************************************************************
char *imp_carac(char *c)
{
int inc;
if(c[strlen(c)-1]<32 || c[strlen(c)-1]>127)
c[strlen(c)-1]='\0';
else
c[strlen(c)]='\0'; //Si un caractère non imprimable est présent en fin de chaîne
//il est remplacé par un caractère de fin de chaîne
for(inc=0;inc<strlen(c);inc++)
{
if(c[inc]>96 && c[inc]<123)
c[inc]=c[inc]-32;
} //Remplace les lettres minuscules en lettres majuscules
return c;
}
//***************************************************************************************************************
//************************************** Fonction Appartient ****************************************************
//***************************************************************************************************************
//*************************Vérifie si un caractère possède bien une traduction Morse*****************************
//***************************************************************************************************************
booleen appartient(char c, Alphabet A)
{
if(estVide(A))
return 0;
else if (c==rec_carac(A))
return 1;
else
return appartient(c, reste(A));
}
//**************************************************************************************************************
//***********************************************Fonction rcode*************************************************
//**************************************************************************************************************
//******Donne le code en fonction du caractère (s'il n'est pas dans l'Alphabet, le programme renvoie "ERR"******
//**************************************************************************************************************
char *rcode(char c, Alphabet A)
{
if(estVide(A))
return "ERR";
else if(c==rec_carac(A))
return rec_code(A);
else
return rcode(c,reste(A));
}
//**************************************************************************************************************
//*************************************************Fonction rcarac**********************************************
//**************************************************************************************************************
//*******Donne le caractère en fonction du code (s'il n'est pas dans l'Alphabet, le programme renvoie "#"*******
//**************************************************************************************************************
char rcarac(char *c,Alphabet A)
{
if(estVide(A))
return '#';
else if(!strcmp(c,rec_code(A)))
return rec_carac(A);
else
return rcarac(c,reste(A));
}
//**************************************************************************************************************
//*********************************************Fonction InsertionFin********************************************
//**************************************************************************************************************
//****************************Insère un caracère et son code Morse en fin d'Alphabet****************************
//**************************************************************************************************************
Alphabet InsertionFin(char ca, char *co, Alphabet A)
{
if(estVide(A))
return cons(ca,co,NULL);
else
return cons(rec_carac(A), rec_code(A), InsertionFin(ca, co, reste(A)));
}
//*************************************************************************************************************
//******************************************Fonction Lecture_Alphabet******************************************
//*************************************************************************************************************
//*****************************Lit le fichier Alphabet. Créée et met à jour la Liste***************************
//*************************************************************************************************************
Alphabet Lecture_Alphabet(char* Fichier)
{
FILE *des;
char *ligne;
char carac;
char *code;
Alphabet A=cons(' '," ",NULL); //crée et initialise la liste avec le caractère espace
ligne=(char*)malloc(256*sizeof(char));
code=(char*)malloc(10*sizeof(char));
des=fopen(Fichier,"r"); //ouvre le fichier Alphabet, en cas d'erreur d'ouverture
if (des==NULL) //le programme s'arrête
{
printf("erreur ouverture\n");
exit(1);
}
while(fgets(ligne,10,des)!=NULL) //Lit chaque ligne du fichier Alphabet et met à jour la liste
{
carac=ligne[0]; //filtre le caractère dans la ligne
strcpy(code,ligne+2); //filtre le code dans la ligne et valide la chaîne avec '\0'
code=imp_carac(code);
if(appartient(carac,A)==0)
A=InsertionFin(carac,code,A); //Insère le nouveau caractère s'il n'existe pas déjà
}
fclose(des);
return A;
}
//*****************************************************************************************************************
//**************************************************Fonction convert**********************************************
//****************************************************************************************************************
//*****************************************Convertion du texte ou du code Morse***********************************
//****************************************************************************************************************
void convert(char *fs,char *fd,Alphabet A, int type_conv)
{
FILE *des_d;
FILE *des_s;
char *ligne;
char *code;
char carac;
int inc;
char *tampon;
ligne=(char*)malloc(512*sizeof(char));
des_s=fopen(fs,"r"); //ouvre le fichier source (Vérification d'erreur)
if(des_s==NULL)
{
printf("\nErreur d'ouverture");
exit(1);
}
des_d=fopen(fd,"w"); //ouvre le fichier destination (Vérification d'erreur)
if(des_d==NULL)
{
printf("\nErreur d'ouverture");
exit(1);
}
if(type_conv==0) //Convertion TEXTE -> MORSE
{
while(fgets(ligne,512,des_s)!=NULL)
{
ligne=imp_carac(ligne); //lecture d'une ligne et validation
for(inc=0;inc<strlen(ligne);inc++)
fprintf(des_d,"%s#",rcode(ligne[inc],A)); //Remplacement de chaque caractère par son code suivi
fprintf(des_d,"\n"); //du caractère de séparation "#"
}
}
else if(type_conv==1) //Convertion MORSE -> TEXTE
{
while(fgets(ligne,512,des_s)!=NULL)
{
tampon=(char*)malloc(512*sizeof(char));
code=(char*)malloc(10*sizeof(char));
ligne=imp_carac(ligne); //Lecture d'une ligne et validation
strcpy(tampon,ligne); //Copie de la ligne dans une chaîne de traitement
do
{
inc=0;
while(tampon[inc]!='#' && inc<strlen(tampon))
{
inc++; //Incrémenter le pointeur de caractère de la ligne jusqu'à la présence
} //d'un caractère de séparation "#"
if(inc<strlen(tampon)) //Réaliser le traitement si on n'est pas au bout de la ligne
{
strncpy(code,tampon,inc);
code[inc]='\0'; //Récupération du code + validation
carac=rcarac(code,A); //Récupération du caractère correspondant
fprintf(des_d,"%c",carac); //Ecriture du caractère dans le fichier de destination
strcpy(tampon,tampon+(inc+1)); //Récupération du reste de la ligne non traité + validation
tampon=imp_carac(tampon);
}
}
while(tampon[0]!=NULL); //Faire tant qu'il y a des caractères dans tampon
fprintf(des_d,"\n");
}
}
fclose(des_s);
fclose(des_d);
}
//**************************************************************************************************************
//**********************************************Programme principal*********************************************
//**************************************************************************************************************
void main(int argc, char* argv[])
{
Alphabet alpha;
int type;
char fichier_alpha[]="./Morse.txt";
char *fichier_alphabetique=(char*)malloc(512*sizeof(char));
char *fichier_morse=(char*)malloc(512*sizeof(char));
printf("\nType de conversion :\n");
printf("0 - Alphabet -> Morse Ecrit\n");
printf("1 - Morse Ecrit -> Alphabet\n");
scanf("%d",&type);
if(type<0 || type>1)
{
printf("\nErreur, type de conversion inconnu");
exit(1);
}
//Lecture de l'alphabet Morse et enregistrement dans une liste
alpha=Lecture_Alphabet(fichier_alpha);
if(type==0)
{
if(argc<3)
{
printf("\nErreur, il faut specifier un fichier source de type alphabetique et un fichier destination de type morse!\n");
exit(1);
}
else
{
fichier_alphabetique=argv[1];
fichier_morse=argv[2];
convert(fichier_alphabetique,fichier_morse,alpha,0);
}
}
else
{
if(argc<3)
{
printf("\nErreur, il faut specifier un fichier source de type morse et un fichier destination de type alphabetique!\n");
exit(1);
}
else
{
fichier_morse=argv[1];
fichier_alphabetique=argv[2];
convert(fichier_morse,fichier_alphabetique,alpha,1);
}
}
}
le fichier texte contenant l'alphabet morse: Morse.txt
A .-
B -...
C -.-.
D -..
E .
F ..-.
G --.
H ....
I ..
J .---
K -.-
L .-..
M --
N -.
O ---
P .--.
Q --.-
R .-.
S ...
T -
U ..-
V ...-
W .--
X -..-
Y -.--
Z --..
0 -----
1 .----
2 ..---
3 ...--
4 ....-
5 .....
6 -....
7 --...
8 ---..
9 ----.
. .-.-.-
, --..--
? ..--..
' .----.
! -.-.--
/ -..-.
( -.--.
) -.--.-
& .--...
: ---...
; -.-.-.
= -...-
+ .-.-.
- -....-
_ ..--.-
" .-..-.
$ ...-..-
@ .--.-.
Il s'agit d'un programme de conversion alphabétique / Morse. C'est un DM que je dois faire pour mon iut.
Le prog fonctionne nickel sur le pc où je compile.
Il y a un fichier .h où j'y ai mis des fonctions basiques gérant des listes chaînées
un fichier .cpp où j'y ai mis les fonctions plus complexes liée à la conversion + le main
un fichier .txt où j'y ai mis un alphabet morse
Le prog lis le fichier .txt et enregistre l'alphabet morse dans une liste chaînée où il y a un caractère (le caractère alphabétique), une chaine de caractères (l'équivalent en morse) et un pointeur sur un autre élément de la chaîne.
Ensuite, il lis un fichier alphabétique et compare chaque caractères du fichier avec la liste chaînée, le trouve dans cette liste, récupère le code correspondant et l'inscrit dans un autre fichier.
(Mon prog peut faire l'inverse également)
Note: le fichier texte avec l'alphabet Morse doit se trouver dans le même répertoire que l'exécutable
par contre, il faut mettre le fichier source et le fichier destination (dans cette ordre) en paramètre lors de l'exécution du programme.
Fichier liste.h
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define LIGNE_MAX 256;
#define CODE_MAX 10;
typedef int booleen;
struct element{
char caractere;
char code[10];
struct element *suiv;
};
typedef struct element Element;
typedef struct element* Alphabet;
booleen estVide(Alphabet A)
{
return (A==NULL);
}
char rec_carac(Alphabet A)
{
return A->caractere;
}
char *rec_code(Alphabet A)
{
return A->code;
}
Alphabet reste(Alphabet A)
{
return A->suiv;
}
Alphabet cons(char ca, char *co, Alphabet A)
{
Alphabet p;
p=(Alphabet)malloc(sizeof(Element));
p->caractere=ca;
strcpy(p->code,co);
p->suiv=A;
return p;
}
fichier Morse1.2.cpp
#include "Liste.h"
#include <stdlib.h>
//******************************************************************************************************************
//***********************************************Fonction imp_carac*************************************************
//******************************************************************************************************************
//***************Vérifie et valide la chaîne de caractères. Remplace les minuscules par des majuscules**************
//******************************************************************************************************************
char *imp_carac(char *c)
{
int inc;
if(c[strlen(c)-1]<32 || c[strlen(c)-1]>127)
c[strlen(c)-1]='\0';
else
c[strlen(c)]='\0'; //Si un caractère non imprimable est présent en fin de chaîne
//il est remplacé par un caractère de fin de chaîne
for(inc=0;inc<strlen(c);inc++)
{
if(c[inc]>96 && c[inc]<123)
c[inc]=c[inc]-32;
} //Remplace les lettres minuscules en lettres majuscules
return c;
}
//***************************************************************************************************************
//************************************** Fonction Appartient ****************************************************
//***************************************************************************************************************
//*************************Vérifie si un caractère possède bien une traduction Morse*****************************
//***************************************************************************************************************
booleen appartient(char c, Alphabet A)
{
if(estVide(A))
return 0;
else if (c==rec_carac(A))
return 1;
else
return appartient(c, reste(A));
}
//**************************************************************************************************************
//***********************************************Fonction rcode*************************************************
//**************************************************************************************************************
//******Donne le code en fonction du caractère (s'il n'est pas dans l'Alphabet, le programme renvoie "ERR"******
//**************************************************************************************************************
char *rcode(char c, Alphabet A)
{
if(estVide(A))
return "ERR";
else if(c==rec_carac(A))
return rec_code(A);
else
return rcode(c,reste(A));
}
//**************************************************************************************************************
//*************************************************Fonction rcarac**********************************************
//**************************************************************************************************************
//*******Donne le caractère en fonction du code (s'il n'est pas dans l'Alphabet, le programme renvoie "#"*******
//**************************************************************************************************************
char rcarac(char *c,Alphabet A)
{
if(estVide(A))
return '#';
else if(!strcmp(c,rec_code(A)))
return rec_carac(A);
else
return rcarac(c,reste(A));
}
//**************************************************************************************************************
//*********************************************Fonction InsertionFin********************************************
//**************************************************************************************************************
//****************************Insère un caracère et son code Morse en fin d'Alphabet****************************
//**************************************************************************************************************
Alphabet InsertionFin(char ca, char *co, Alphabet A)
{
if(estVide(A))
return cons(ca,co,NULL);
else
return cons(rec_carac(A), rec_code(A), InsertionFin(ca, co, reste(A)));
}
//*************************************************************************************************************
//******************************************Fonction Lecture_Alphabet******************************************
//*************************************************************************************************************
//*****************************Lit le fichier Alphabet. Créée et met à jour la Liste***************************
//*************************************************************************************************************
Alphabet Lecture_Alphabet(char* Fichier)
{
FILE *des;
char *ligne;
char carac;
char *code;
Alphabet A=cons(' '," ",NULL); //crée et initialise la liste avec le caractère espace
ligne=(char*)malloc(256*sizeof(char));
code=(char*)malloc(10*sizeof(char));
des=fopen(Fichier,"r"); //ouvre le fichier Alphabet, en cas d'erreur d'ouverture
if (des==NULL) //le programme s'arrête
{
printf("erreur ouverture\n");
exit(1);
}
while(fgets(ligne,10,des)!=NULL) //Lit chaque ligne du fichier Alphabet et met à jour la liste
{
carac=ligne[0]; //filtre le caractère dans la ligne
strcpy(code,ligne+2); //filtre le code dans la ligne et valide la chaîne avec '\0'
code=imp_carac(code);
if(appartient(carac,A)==0)
A=InsertionFin(carac,code,A); //Insère le nouveau caractère s'il n'existe pas déjà
}
fclose(des);
return A;
}
//*****************************************************************************************************************
//**************************************************Fonction convert**********************************************
//****************************************************************************************************************
//*****************************************Convertion du texte ou du code Morse***********************************
//****************************************************************************************************************
void convert(char *fs,char *fd,Alphabet A, int type_conv)
{
FILE *des_d;
FILE *des_s;
char *ligne;
char *code;
char carac;
int inc;
char *tampon;
ligne=(char*)malloc(512*sizeof(char));
des_s=fopen(fs,"r"); //ouvre le fichier source (Vérification d'erreur)
if(des_s==NULL)
{
printf("\nErreur d'ouverture");
exit(1);
}
des_d=fopen(fd,"w"); //ouvre le fichier destination (Vérification d'erreur)
if(des_d==NULL)
{
printf("\nErreur d'ouverture");
exit(1);
}
if(type_conv==0) //Convertion TEXTE -> MORSE
{
while(fgets(ligne,512,des_s)!=NULL)
{
ligne=imp_carac(ligne); //lecture d'une ligne et validation
for(inc=0;inc<strlen(ligne);inc++)
fprintf(des_d,"%s#",rcode(ligne[inc],A)); //Remplacement de chaque caractère par son code suivi
fprintf(des_d,"\n"); //du caractère de séparation "#"
}
}
else if(type_conv==1) //Convertion MORSE -> TEXTE
{
while(fgets(ligne,512,des_s)!=NULL)
{
tampon=(char*)malloc(512*sizeof(char));
code=(char*)malloc(10*sizeof(char));
ligne=imp_carac(ligne); //Lecture d'une ligne et validation
strcpy(tampon,ligne); //Copie de la ligne dans une chaîne de traitement
do
{
inc=0;
while(tampon[inc]!='#' && inc<strlen(tampon))
{
inc++; //Incrémenter le pointeur de caractère de la ligne jusqu'à la présence
} //d'un caractère de séparation "#"
if(inc<strlen(tampon)) //Réaliser le traitement si on n'est pas au bout de la ligne
{
strncpy(code,tampon,inc);
code[inc]='\0'; //Récupération du code + validation
carac=rcarac(code,A); //Récupération du caractère correspondant
fprintf(des_d,"%c",carac); //Ecriture du caractère dans le fichier de destination
strcpy(tampon,tampon+(inc+1)); //Récupération du reste de la ligne non traité + validation
tampon=imp_carac(tampon);
}
}
while(tampon[0]!=NULL); //Faire tant qu'il y a des caractères dans tampon
fprintf(des_d,"\n");
}
}
fclose(des_s);
fclose(des_d);
}
//**************************************************************************************************************
//**********************************************Programme principal*********************************************
//**************************************************************************************************************
void main(int argc, char* argv[])
{
Alphabet alpha;
int type;
char fichier_alpha[]="./Morse.txt";
char *fichier_alphabetique=(char*)malloc(512*sizeof(char));
char *fichier_morse=(char*)malloc(512*sizeof(char));
printf("\nType de conversion :\n");
printf("0 - Alphabet -> Morse Ecrit\n");
printf("1 - Morse Ecrit -> Alphabet\n");
scanf("%d",&type);
if(type<0 || type>1)
{
printf("\nErreur, type de conversion inconnu");
exit(1);
}
//Lecture de l'alphabet Morse et enregistrement dans une liste
alpha=Lecture_Alphabet(fichier_alpha);
if(type==0)
{
if(argc<3)
{
printf("\nErreur, il faut specifier un fichier source de type alphabetique et un fichier destination de type morse!\n");
exit(1);
}
else
{
fichier_alphabetique=argv[1];
fichier_morse=argv[2];
convert(fichier_alphabetique,fichier_morse,alpha,0);
}
}
else
{
if(argc<3)
{
printf("\nErreur, il faut specifier un fichier source de type morse et un fichier destination de type alphabetique!\n");
exit(1);
}
else
{
fichier_morse=argv[1];
fichier_alphabetique=argv[2];
convert(fichier_morse,fichier_alphabetique,alpha,1);
}
}
}
le fichier texte contenant l'alphabet morse: Morse.txt
A .-
B -...
C -.-.
D -..
E .
F ..-.
G --.
H ....
I ..
J .---
K -.-
L .-..
M --
N -.
O ---
P .--.
Q --.-
R .-.
S ...
T -
U ..-
V ...-
W .--
X -..-
Y -.--
Z --..
0 -----
1 .----
2 ..---
3 ...--
4 ....-
5 .....
6 -....
7 --...
8 ---..
9 ----.
. .-.-.-
, --..--
? ..--..
' .----.
! -.-.--
/ -..-.
( -.--.
) -.--.-
& .--...
: ---...
; -.-.-.
= -...-
+ .-.-.
- -....-
_ ..--.-
" .-..-.
$ ...-..-
@ .--.-.
