De retour au langage C

Version imprimable

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

Bonjour
Après trop d'années a ne pas avoir écrit la moindre ligne en C, je m'y remets.
J'ai installé cygwin64 au vu des conseils d'un post du site.
J'ai installé l'IDE cpp-neon Éclipse.

Pour effectuer un test des plus primaires :

j'ai écrit un énorme programme C
Code:

1 2 3 4 5 6 7 8 #include <stdio.h> int main() { printf("Ce programme permet de copier un fichier.\n"); return 0; }
… et voici le résultat du compilateur :

Quel est son problème ?
C:\cygwin64\bin est présent dans le path
12:14:25 **** Build of configuration Debug for project LIREFIC ****
make all 
Cannot run program "make": Launching failed

Error: Program "make" not found in PATH
PATH=[C:\cygwin64\bin;C:/Program Files/Java/jdk1.8.0_91/jre/bin/server;C:/Program Files/Java/jdk1.8.0_91/jre/bin;C:/Program Files/Java/jdk1.8.0_91/jre/lib/amd64;C:\WINDOWS\system32;C:\WINDOWS;C:\WINDOWS\System32\Wbem;C:\WINDOWS\System32\WindowsPowerShell\v1.0\;C:\Users\dedalios\eclipse\cpp-neon\eclipse]

12:14:25 Build Finished (took 139ms)
CYGWIN_HOME pointe sur C:\cygwin64

Auriez-vous une idée pour résoudre mon problème ?
Merci.

AUtres chose Avec CodeBolck+miwgcc pas de problème

01/04/2017, 20h23
foetus

C'est écrit noir sur blanc :sm: Il te manque le logiciel make (+ peut être les binutils, autotools, ....)

Pour un programme aussi trivial, lance une console cygwin64 et tape soit "gcc my_prog.c" soit "gcc my_prog.c -o my_prog"

Et la signature de main n'est pas bonne :whistle: : int main(int /*argc*/, char* /*argv*/[]) {}
01/04/2017, 22h10
Sve@r

Bonjour

Citation:

Envoyé par dedalios

J'ai installé cygwin64 au vu des conseils d'un post du site.

Ben pas d'un des miens. Pour du C j'aurais plutôt conseillé "mingw". Mais bon, ça dépend aussi de ce qu'on veut faire après...

Citation:

Envoyé par foetus

Et la signature de main n'est pas bonne :whistle: : int main(int /*argc*/, char* /*argv*/[]) {}

En réalité la signature est plutôt int main(int /*argc*/, char* /*argv*/[], char* /*envp*/[]) {} :whistle: ...
Et en fait t'as tout à fait le droit de ne pas déclarer les arguments que tu n'utilises pas.
02/04/2017, 11h34
picodev

Bonjour,
juste en ce qui concerne la fonction main, la norme C11 impose à la section 5.1.2.2.1 Program Startup :

Citation:

The function called at program startup is named main. The implementation declares no prototype for this function. It shall be defined with a return type of int and with no parameters:
int main(void) { /* ... */ }
or with two parameters (referred to here as argc and argv, though any names may be used, as they are local to the function in which they are declared):
int main(int argc, char *argv[]) { /* ... */ }
or equivalent or in some other implementation-defined manner.

En gros, si on veut être portable et conforme on choisit une des définitions suivant le besoin ou non de connaître les paramètres de la ligne de commande. Tout autre définition de main peut causer des problèmes de portabilités.

C'est aussi ce que la norme répète à l'annexe J5 où elle note qu'une extension commune est d'avoir un troisième argument pour main sur les plateformes disposant d'un OS :

Citation:

In a hosted environment, the main function receives a third argument, char *envp[], that points to a null-terminated array of pointers to char, each of which points to a string that provides information about the environment for this execution of the program (5.1.2.2.1).

Mais rappelle que l'utilisation de ces extensions rend les programmes non conformes.

Citation:

The following extensions are widely used in many systems, but are not portable to all implementations. The inclusion of any extension that may cause a strictly conforming program to become invalid renders an implementation nonconforming.

code a voir

j'ai mis aussi en place codeblock comme ide avec mingcc

voici un bon de code .

La phase de lecteur ne fonctionne pas ?
pourquoi alors que le fichier est plein n'y a til aucun affiche dns le printf .
Je suppose que le scan n'est de plus pas adapté ici?

Code:

1
2
3
4
           if(fichierLu != NULL){
           fscanf(fichierLu, "%c", &caracLu);
                printf("le caractere %c" , &caracLu);
           }

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
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
 
/* Les deux paramètres de la fonction main() pour récupérer les
   arguments de la ligne de commande */
#define TAILLE_BLOC 128
int main(int argc, char *argv[])
{
    FILE* fichierLu = NULL;
    FILE* fichierEc = NULL;
    char* fichierNM = NULL;
    char caracLu =  NULL;
    int i;
    char bloc128[128];
    if (argc <= 1) {
    printf("\nLe programme n'a reçu aucun argument\n");
    }
    else {
 
    }
    fichierNM = "C:\\Users\\moi\\Documents\\fic\\OPIL-203330-20161225220501";
    fichierLu = fopen(fichierNM, "r");
    if(fichierLu = NULL)
        {
            printf("Le fichier n'existe pas");
        }
        else
        {
            printf("ouvrir %s \n" ,fichierNM );
           if(fichierLu != NULL){
           fscanf(fichierLu, "%c", &caracLu);
                printf("le caractere %c" , &caracLu);
           }
        }
        fclose(fichierLu);
 
    return EXIT_SUCCESS;
 
}

y til beaucoup de post sur la lecture de fichier lequel serait le plus pertinent pour :
LE but lire un fichier AIX (unix) sous windows par bloc de 50 caractères .
le fichier fait 100 caractères ou 500 caractères un multi de50 dans aucune fin de ligne.
on découpe par bloc de 50
chaque bloc est analyse dans un tableau de 50 C

Code:

char bloc50[50];

puis selon des règles non définie ici est modifié pour être écrit dans un fichier de sortie.

voici le début de l'analyse ( cette partie ne peut pas selon moi être traitée sous forme de chaine à cause de caractère /0 qui risque d'altérer les données)
et ce n'est pas ce point qui m’intéresse.

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
int verifier_128(char zone[50])
{
  	int i;
  	char codetype;
	for(i=0; i<51;i++)
    {
        printf("%c\n",zone[i] );
        codetype =  zone[0] ;
        switch (codetype) {
            case '1':
                type1(zone);
                break;
            case '2':
                type2(zone);
                break;
            case '4':
                type4(zone);
            break;
          }
    }
}
 
int type1(char zone[50]) {
         printf("type 1\n");
}
 
 int type2(char zone[50]) {
         printf("type 1\n");
}
int type4(char zone[50]) {
         printf("type 1\n");
}

ce qui m’intéresse en premier lieu c'est la lecture et écriture du fichier
et donc les post sur ce thème

Dans le code que tu proposes il y a plusieurs problèmes et incompréhenrions.
Par exemple le compilateur a dû t'avertir sur : if(fichierLu = NULL) non ?

Mais dans l'ordre on a :

char caracLu = NULL; : pas vraiment faux mais pas juste non plus. NULL est réservé pour les pointeurs pas pour les caractères (qui sont un type entier). Pour être correct tu devrais simplement écrire char caracLu = 0; ou char caracLu = '\0';. Le pointeur NULL et le caractère nul sont deux choses différentes.
Code:

1 2 3 4 5 6 7 8 if(fichierLu = NULL) { printf("Le fichier n'existe pas"); } else { printf("ouvrir %s \n" ,fichierNM ); if(fichierLu != NULL){
Le dernier if est inutile car tu es dans le else, un endroit où tu es déjà certaine que fichierLu n'est pas NULL.
Code:

1 2 3 4 5 6 7 8 9 if(fichierLu = NULL) { printf("Le fichier n'existe pas"); } else { ... } fclose(fichierLu);
on ne ferme un fichier que dans le cas où on a réussi à l'ouvrir, sinon UB.

Il faut toujours vérifier la valeur de retour de fscanf pour savoir la lecture n'a pas échouée (man fscanf).

Si tu affiches un char avec un %c tu vas afficher un caractère ascii qui sera pas toujours affichable en console. Windows fait une distinction claire entre fichier texte et fichier binaire.

je suis vraiment rouillé en C 20 ans sans le codé ... ça fait de dégâts merci pour les conseils

Quand au problème sous cygwin / Eclipse : 2 machines avec réinstallations complete cigwin +eclipse
L'une réagit sans problème et l'autre ne trouve pas le make...

et je ne lit même pas les alertes tu as raison picodev

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
 
12:34:33 **** Incremental Build of configuration Debug for project Testc ****
make all 
Building file: ../main.c
Invoking: Cygwin C Compiler
gcc -O0 -g3 -Wall -c -fmessage-length=0 -MMD -MP -MF"main.d" -MT"main.o" -o "main.o" "../main.c"
../main.c: In function 'main':
../main.c:25:5: warning: suggest parentheses around assignment used as truth value [-Wparentheses]
     if(fichierLu = NULL)
     ^
../main.c:34:17: warning: format '%c' expects argument of type 'int', but argument 2 has type 'char *' [-Wformat=]
                 printf("le caractere %c" , &caracLu);
                 ^
../main.c:16:10: warning: unused variable 'bloc128' [-Wunused-variable]
     char bloc128[128];
          ^
../main.c:15:9: warning: unused variable 'i' [-Wunused-variable]
     int i;
         ^
../main.c:12:11: warning: unused variable 'fichierEc' [-Wunused-variable]
     FILE* fichierEc = NULL;
           ^
Finished building: ../main.c
 
Building target: Testc.exe
Invoking: Cygwin C Linker
gcc  -o "Testc.exe"  ./main.o   
Finished building target: Testc.exe
 
 
12:34:35 Build Finished (took 2s.18ms)

02/04/2017, 13h33
dedalios

Citation:

Envoyé par picodev

Dans le code que tu proposes il y a plusieurs problèmes et incompréhenrions.

Il faut toujours vérifier la valeur de retour de fscanf pour savoir la lecture n'a pas échouée (man fscanf).

Si tu affiches un char avec un %c tu vas afficher un caractère ascii qui sera pas toujours affichable en console. Windows fait une distinction claire entre fichier texte et fichier binaire.

Mon problème est le suivant :
Le fichier lu est donc au format unix non ascii :
Il doit être traité en l'état (Le but n'est pas d'en afficher le contenu ). Les données sont pour certaines éventuellement crypté donc de code qui ne sont pas a proprement parlée lisible et ne doivent pas être altérée.
Mais certaine données au vue de critère de sélection doivent être modifiée. il peut arrive que ces speudos chaines puisse contenir des données de type fin de chaine CR CR/LF LF qui ne devrait pas être la mais je ne créer pas les fichiers .

donc je cherche quelle est la meilleur méthode de lecture du fichier.
et la meilleur solution d'écriture

Si le fichier est fait de clusters faisant tous 50 octets, le plus simple si le fichier est ouvert en mode binary
Code:

1 2 3 unsigned char buffer[50]; size_t nbLus = fread( buffer, sizeof*buffer, sizeof buffer/sizeof*buffer, fileIn ); size_t nbEcris = fwrite( buffer, sizeof*buffer, sizeof buffer/sizeof*buffer, fileOut );
Sinon on peut lire des octets un à un par fgetc( fileIn ).

02/04/2017, 20h25
Sve@r

Citation:

Envoyé par dedalios

Le fichier lu est donc au format unix non ascii :

Sous Unix ça ne veut rien dire. Parce que justement, sous Unix, il n'y a absolument aucune particularité sur les fichiers. Qu'un fichier contienne "Bonjour" ou bien le dernier king kong (ce qui arrivera bientôt) ben quand tu le lis tu ne lis que des octets. Et s'il contient "Bonjour" ben il contient juste "bonjour" et rien d'autre. Ni CR, ni CR/LF ni aucun caractère qu'on trouve d'habitude sous d'autres OS (et qui foutent plus la merde qu'autre chose)...

Citation:

Envoyé par dedalios

donc je cherche quelle est la meilleur méthode de lecture du fichier.

C'est là que c'est chouette: tu utilises ce que tu veux selon ton besoin et non selon la nature du fichier. Donc que tu lises une vidéo, un mp3 ou bien un CSV ben c'est pareil. Si tu veux lire un caractère ben tu utilises fgetc(). Si tu veux lire "n" caractères alors fread(). Ensuite (petite particularité dédiée aux fichiers "human readables" qui sont habituellement composés de lignes terminées par un '\n') il t'est offert deux outils "en plus" (c'est à dire que ça aide mais s'ils n'y étaient pas ce serait possible quand-même): fgets() qui lit "n" caractères mais qui s'arrête quand elle rencontre un '\n', getline() qui est la même mais sans être limité par un nombre de caractères (donc qui peut lire une ligne virtuellement infinie) et fscanf() qui permet de lire une ligne formattée d'une certaine façon et la décomposer selon le format.

PS: quand je dis qu'un fichier "human readable" contient des '\n", ce n'est pas lié à la nature du fichier lui-même (puisqu'Unix ne se préoccupe absolument jamais de la nature de ses fichiers) mais simplement au fait que celui qui remplit le fichier tape 'return' quand il veut aller à la ligne. Donc il tape 'return', le fichier stocke 'return' (symbolisé par '\n'). Rien de plus, rien de moins.
02/04/2017, 21h14
Matt_Houston
Citation:

Envoyé par dedalios

Mon problème est le suivant :
[...]

On manque toujours d'éléments, quel est le traitement à réaliser ? Comment doivent être présentées les données en entrée du traitement puis en sortie du programme ?

Sans plus de détails, comme cela a été fait remarquer il convient de procéder comme suit :
- lire de fichier / flux par blocs d'une taille fixe : celle du buffer d'entrée ;
- traiter les données, soit sur place soit vers un autre buffer ;
- vider le buffer de sortie vers le fichier dès qu'il est plein ou qu'il est impossible d'obtenir plus de données.

test peu concluant

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
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
 
 
#define TAILLE_MAX 128 // Tableau de taille 128
 
int main(int argc, char *argv[])
{
    FILE* fichierLu = NULL;
    unsigned char LeBloc_128[TAILLE_MAX] = ""; // Chaîne vide de taille TAILLE_MAX
    int posfichier = 0;
    int poschaine = 0;
    char caractereActuel;
 
 
    fichierLu = fopen("AM002-203330-20161225220501", "r");
 
    if (fichierLu != NULL)
    {
    	 do {
    		 posfichier = 1;
    		 poschaine = 0;
    		 do {
    			 fread(&caractereActuel,posfichier,1,fichierLu);
    			 LeBloc_128[poschaine] = caractereActuel;
    			 posfichier = posfichier + 1;
    			 poschaine ++;
    		 	 } while (caractereActuel != EOF || poschaine <= TAILLE_MAX);
                         printf("%s\n", LeBloc_128); // On affiche la chaîne
    	 	 } while (caractereActuel != EOF); // On continue tant que fgetc n'a pas retourné EOF (fin de fichier)
 
 
         fclose(fichierLu);
    }
 
    return 0;
}

02/04/2017, 23h01
Matt_Houston
EOF est de type int et non char. Ce n'est pas de cette manière que l'on utilise fread.

Deux conseils :
- se référer au manuel ;
- compiler avec les avertissements : -pedantic -Wall -Wextra.

Puisque tu n'as pas fait de C depuis 20 ans, une remarque quant au style : depuis la version C99 du langage, tu n'es plus obligé de définir toutes tes variables en début de fonction, tu peux les définir où tu le souhaites. Je te conseille personnellement (et je pense que je ne suis pas le seul) de déclarer tes variables au plus proche de l'endroit où tu les utilises. Exception à cette règle : si tu veux préserver une compatibilité avec C89, tu dois continuer à les déclarer en début de fonction. Il est peu probable que ce soit ton cas alors utilise le style moderne :) En particulier, remarque cette écriture d'une boucle for() :
Code:

1 2 3 4 5 6 for (int i = 0; i < N; ++i) { // code utilisant i } // ici, i n'est plus accessible
Autre remarque de style : l'indentation de ton code est mauvaise. En général, les while() sont alignés avec les do correspondants, comme ceci :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 if (fichierLu != NULL) { do { posfichier = 1; poschaine = 0; do { fread(&caractereActuel, posfichier, 1, fichierLu); LeBloc_128[poschaine] = caractereActuel; posfichier = posfichier + 1; poschaine++; } while (caractereActuel != EOF || poschaine <= TAILLE_MAX); printf("%s\n", LeBloc_128); // On affiche la chaîne } while (caractereActuel != EOF); // On continue tant que fgetc n'a pas retourné EOF (fin de fichier) fclose(fichierLu); }
Citation:

// On continue tant que fgetc n'a pas retourné EOF (fin de fichier)

Ce commentaire me semble de toute évidence faux puisque tu n'utilises pas fgetc()...

Ce code ne fonctionne pas et provoque un bug

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
  if (fichierLu != NULL)
    {
        do
        {
            posfichier = 1;
            poschaine = 0;
            do
            {
                fread(&caractereActuel, posfichier, 1, fichierLu);
                LeBloc_128[poschaine] = caractereActuel;
                posfichier = posfichier + 1;
                poschaine++;
            } while (caractereActuel != EOF || poschaine <= TAILLE_MAX);
            printf("%s\n", LeBloc_128); // On affiche la chaîne
        } while (caractereActuel != EOF); // On continue tant que fgetc n'a pas retourné EOF (fin de fichier)
 
        fclose(fichierLu);
    }

Ce code ne fonctionne pas
il echoue dans

Code:

1
2
3
 
                fread(&caractereActuel, posfichier, 1, fichierLu);
                LeBloc_128[poschaine] = caractereActuel;

Process returned -1073741819 (0xC0000005) execution time : 3.115 s

03/04/2017, 18h35
Sve@r

Citation:

Envoyé par Bktero

si tu veux préserver une compatibilité avec C89, tu dois continuer à les déclarer en début de ~~fonction~~

en début de bloc (nuance...) ;)

Citation:

Envoyé par Bktero

Ce commentaire me semble de toute évidence faux puisque tu n'utilises pas fgetc()...

:applo: :mouarf:

Citation:

Envoyé par dedalios

Ce code ne fonctionne pas
il echoue daans

Code:

LeBloc_128[poschaine] = caractereActuel;

Process returned -1073741819 (0xC0000005) execution time : 3.115 s

Mouais. Je comprends que dalle à ce que tu tentes de faire avec tes "posFichier" et "posChaine". Je ne dis pas que ça ne peut pas fonctionner (je rentre du taf et je suis un peu vanné donc c'est sans doute la raison pour laquelle je décroche avec ton code) mais même si ça peut fonctionner, je sens confusément qu'on doit probablement pouvoir faire la même chose en plus simple que ton code (qu'on nomme généralement dans ce cas là "usine à gaz").

A la réflexion il y a quand-même un gros bug: tu remplis une variable "LeBloc_128" caractère par caractère à partir des caractères lus. Accessoirement faire un fread() pour lire un caractère c'est un peu comme quand dame Seli tente de choper une souris avec un maillet (Kaamelott). Donc tu remplis une variable que tu affiches avec printf("%s"). Et à quel moment tu lui mets le '\0' à ta variable ???

Donc non, je confirme qu'il y a bien plus simple pour lire une ligne et l'afficher. Peut-être fgets() dont j'ai déjà parlé...
03/04/2017, 18h36
picodev

À ton avis, la conditionnelle caractereActuel != EOF || poschaine <= TAILLE_MAX est fausse quand ? Je crois qu'il va falloir revoir ça …
Ensuite utiliser fread pour lire byte par byte et remplir un buffer, c'est pas forcément le mieux que tu puisses faire. Regarde à quoi sert et comment on utilise fread ; avec un simple man tu as :

Citation:

NAME
fread, fwrite - binary stream input/output

SYNOPSIS
#include <stdio.h>

size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream);

size_t fwrite(const void *ptr, size_t size, size_t nmemb,
FILE *stream);

DESCRIPTION
The function fread() reads nmemb items of data, each size bytes long, from the stream pointed to by stream,
storing them at the location given by ptr.

...
RETURN VALUE
On success, fread() and fwrite() return the number of items read or written. This number equals the number of
bytes transferred only when size is 1. If an error occurs, or the end of the file is reached, the return value
is a short item count (or zero).

fread() does not distinguish between end-of-file and error, and callers must use feof(3) and ferror(3) to
determine which occurred.
...

Tu as un buffer de taille 128 bytes ? Tu veux le remplir en lisant les données dans un flux ? Alors pourquoi ne pas faire simplement size_t bytes_read = fread(LeBloc_128, 1, 128, fichierLu); ? Ensuite tu réagis suivant la valeur de retour de fread → le buffer est complètement rempli, en partie rempli, pas du tout rempli et dans ce cas est-ce dû à une erreur (man ferror) ou une fin de fichier (man feof) …

exemple2

j'ai testé autre chose sans lire je l'avoue le précédent poste
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 #include <stdio.h> #include <stdlib.h> #include <string.h> #include <math.h> #define TAILLE_MAX 128 // Tableau de taille 128 int main(int argc, char *argv[]) { FILE* fichierLu = NULL; unsigned char LeBloc_128[TAILLE_MAX] = ""; fichierLu = fopen("AM002-203330-20161225220501", "r"); if (fichierLu != NULL) { int Lecar; do { int i = 0; do { Lecar = getc(fichierLu); putchar(Lecar); LeBloc_128[i] = Lecar; i++; } while( (Lecar != EOF) !! (i <= TAILLE_MAX) ); printf("%s /n" ,LeBloc_128); printf("***"); } while( Lecar != EOF ); fclose(fichierLu); } else { printf("Pas de fichier"); } return 0; }
et voici ce que donne le compilateur

||=== Build: Debug in programmen2 (compiler: GNU GCC Compiler) ===|
main.c||In function 'main':|
main.c|25|error: expected ')' before '!' token
||=== Build failed: 1 error(s), 0 warning(s) (0 minute(s), 0 second(s)) ===|

03/04/2017, 23h53
picodev

Et c'est quoi !! ? Tu pensais sans doute écrire || ?

Sinon en français, tu veux lire tant que tu n'atteins pas la fin du fichier et qu'il y a encore de la place dans le buffer …
04/04/2017, 07h35
dedalios

Citation:

Envoyé par picodev

Et c'est quoi !! ? Tu pensais sans doute écrire || ?

Sinon en français, tu veux lire tant que tu n'atteins pas la fin du fichier et qu'il y a encore de la place dans le buffer …

ou lala merci pour vos aide a tous 20 ans sans code sa fait de dégât :(:(:(

le fichier est constituer de bloc de 128 caractères. Je recherche donc a extraire ces X block de 128 caractères pour les analyser.

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