Discussion :

[dedalios]

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 :

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

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

[foetus]

C'est écrit noir sur blanc 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 : int main(int /*argc*/, char* /*argv*/[]) {}

[Sve@r]

Bonjour

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...

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

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

[picodev]

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

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 :

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.

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.

[dedalios]

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 :

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

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

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
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 :

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

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 :

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

[picodev]

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 :

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

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 :

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

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.

[dedalios]

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 :

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
 
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)

[dedalios]

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

[dalfab]

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

Code :

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

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 ).

[Sve@r]

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)...

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.

[Matt_Houston]

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.

[dedalios]

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

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

[Bktero]

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 :

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

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 :

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

// 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()...

[dedalios]

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
  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 :

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

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

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

[Sve@r]

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...)

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

Ce code ne fonctionne pas
il echoue daans

Code :

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

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é...

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

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) …

[dedalios]

j'ai testé autre chose sans lire je l'avoue le précédent poste

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
#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)) ===|

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

[dedalios]

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.