Question sur la mémoire et les fichiers

Version imprimable

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

Voici le premier code que j'avais ecrit :

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
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
#include <stdio.h>
#include <stdlib.h>
#include "crypt.h"
 
void crypt()
{
    char chaine[100] = "";
    char chaine2[20] = "";
    FILE *fichier = NULL; // Fichier d'origine
    FILE *crypt = NULL; // fichier crypté
    int taille = 0, i = 0, j = 0; // Taille pour malloc
    char *tableau = NULL;
 
    printf("Placer le fichier a crypter dans le meme dossier que le programme.\n");
    printf("Indiquez son nom (son extension y compris ex : fichier.ext).");
    printf("\nAttention la console ne gere pas les accents et les espaces !!!\n");
    scanf("%100s", chaine); // Adresse du fichier
    fichier = fopen(chaine, "rb"); // En mode lecture binaire
    if (fichier == NULL) // Si y a erreur
    {
     printf( "Erreur d'ouverture du fichier." );
     exit( EXIT_FAILURE );
    }
 
    fseek( fichier, 0, SEEK_END); // La taille pour le malloc
    taille = ftell( fichier );
    rewind( fichier );
 
    tableau = malloc ( taille * sizeof(char)); // Allocation dynamique
 
    if ( fread( tableau, 1, taille, fichier) < taille ) // tableau, taille par paquet, nombre de paquet, flux d'entrée
    // fread renvoi le nombre d'element lu
    {
        printf("Le programme n'a pas pu tout crypter"); // Test d'erreur si on a reussi a tout lire
        exit ( EXIT_FAILURE );
    }
 
    printf("\nDonnez un mot de passe pour crypter : ");
    getchar();
    fgets(chaine2, 19, stdin);
 
    for ( i = 0; i < taille; i ++ ) // Cryptage
    {
     tableau[i] = tableau[i] ^ chaine2[j]; // Fonction XOR
     if (j == 19)
     {
      j = 0; // Si le mdp arrive a la fin je dois le reinitialiser
     }
     j++;
    }
 
    crypt = fopen( "crypt.cr", "wb");
 
    if ( fwrite( tableau, 1, taille, crypt) < taille ) // Pareil que fread, fichier de sortie
    {
        printf("Le programme n'a pas pu tout crypter"); // gestion d'erreur
        exit ( EXIT_FAILURE );
    }
 
    printf("\nLe fichier crypte a ete place dans le meme dossier et est nomme \"crypt.cr\".");
    printf("\nAppuyer sur une touche pour continuer");
    getch();
 
    fclose(fichier); //Liberation memoire
    fclose(crypt);
    free(tableau);
 
}

Puis a la suite du post :

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
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
 
#include <stdio.h>
#include <stdlib.h>
#include "crypt.h"
 
void crypt()
{
    char chaine[100] = ""; // adresse
    char chaine2[20] = ""; // mot de passe
    FILE *fichier = NULL; // Fichier d'origine
    FILE *crypt = NULL; // fichier crypté
    int taille = 0, j = 0; // Taille pour test d'erreur
    char tableau[2] = ""; // tableau de cryptage
//---------------------------------------------------------------------------------------------------------------------------------------------- Var / bases
 
    printf("Placer le fichier a crypter dans le meme dossier que le programme.\n");
    printf("Indiquez son nom (son extension y compris ex : fichier.ext).");
    printf("\nAttention la console ne gere pas les accents et les espaces !!!\n");
    scanf("%100s", chaine); // Adresse du fichier
    fichier = fopen(chaine, "rb"); // En mode lecture binaire
    if (fichier == NULL) // Si y a erreur
    {
     printf( "Erreur d'ouverture du fichier." );
     exit( EXIT_FAILURE );
    }
 
    fseek(fichier, 0, SEEK_END);
    taille = ftell(fichier);
    rewind(fichier);
 
    printf("\nDonnez un mot de passe pour crypter : ");
    getchar();
    fgets(chaine2, 19, stdin);
 
//------------------------------------------------------------------------------------------------------------------------------------------------ CRYPTAGE, LECTURE
while ( ftell(fichier) != taille )
{
    fread( tableau, 1, 1, fichier);
 
//--------------------------------------------------------------------------------------------------------------------------------------------------- XOR (cryptage)
 
     tableau[0] = tableau[0] ^ chaine2[j]; // Fonction XOR
     if ( chaine2[j] == '\0' )
     {
         j = 0;
     }
     else
     {
         j++;
     }
 
//--------------------------------------------------------------------------------------------------------------------------------------------------- ECRITURE
    crypt = fopen( "crypt.cr", "wb");
 
    fwrite( tableau, 1, 1, crypt);
}
 
//----------------------------------------------------------------------------------------------------------------------------------------------------- SUCCES
    printf("\nLe fichier crypte a ete place dans le meme dossier et est nomme \"crypt.cr\".");
    printf("\nAppuyer sur une touche pour continuer");
    getch();
 
    fclose(fichier); //Liberation memoire
    fclose(crypt);
    free(tableau);
 
}

Ouille ! Désolé mais, effectivement, ton programme est un festival d'erreurs. Ce n'est pas grave, on est tous passés par là. Donc :
Code:

1 2 3 4 #include <stdio.h> #include <stdlib.h> #include "crypt.h"
Le code que tu nous montres ne contient pas « crypt.h », mais cela n'a pas d'importance. En revanche, il n'y a pas de fonction main(). En l'ajoutant et en appelant directement ta fonction, ça fonctionne quand même.
Code:

1 2 3 4 5 6 void crypt() { char chaine[100] = ""; // adresse char chaine2[20] = ""; // mot de passe FILE *fichier = NULL; // Fichier d'origine FILE *crypt = NULL; // fichier crypté
Tu as une fonction qui s'appelle « crypt » et un pointeur vers le descripteur d'un fichier qui s'apelle « crypt » aussi. C'est légal, mais c'est quand même le meilleur moyen de s'attirer des problèmes.
Code:

1 2 3 fseek(fichier, 0, SEEK_END); taille = ftell(fichier); rewind(fichier);
C'est effectivement le (seul ?) moyen de le faire si on veut s'en tenir au C standard et faire quelque chose d'universellement portable. Pourtant, ce n'est pas forcément la meilleure solution. stat() ou GetFileSize() sous Windows seraient plus appropriés, comme débattu sur ce fil.
Code:

1 2 3 while ( ftell(fichier) != taille ) { fread( tableau, 1, 1, fichier);
Ça non plus, ce n'est pas ce qu'il y a de mieux, surtout que cela t'empêche de savoir si une erreur eventuelle s'est produite. À la place, vérifie la valeur de retour de fread(), qui correspond au nombre de caractères lus. S'il est inférieur à ce que tu as demandé, c'est que tu as atteint la fin du fichier ou qu'une erreur s'est effectivement produite. Utilise alors feof() et ferror() pour en avoir le cœur net.
Code:

1 2 3 4 5 6 7 8 9 10 11 //--------------------------------------------------------------------------------------------------------------------------------------------------- XOR (cryptage) tableau[0] = tableau[0] ^ chaine2[j]; // Fonction XOR if ( chaine2[j] == '\0' ) { j = 0; } else { j++; }
Tu testes la fin de la chaîne « \0 » après avoir fait ton mélange. Ce qui fait que ce « \0 » final est impliqué dans ton cryptage. Donc, à intervalles réguliers, tu auras un caractère qui restera inchangé.
Code:

1 2 3 4 5 //--------------------------------------------------------------------------------------------------------------------------------------------------- ECRITURE crypt = fopen( "crypt.cr", "wb"); fwrite( tableau, 1, 1, crypt); }
ATTENTION : tu réouvres ton fichier à chaque tour de boucle (donc, à chaque caractère) sans refermer le précédent. Le contenu de ton pointeur est écrasé, mais cela ne veut pas dire que le système a automatiquement refermé le fichier qu'il décrivait.

Dans mon débogueur, ton programme plante après la 1017 itération, ce qui correspond à peu près aux 1024 fichiers que tu peux ouvrir simultanément par défaut (sous Linux). Il plante sur la ligne 54 « fwrite », parce que « crypt » est égal à NULL, ce qui confirme mes dires.
Code:

1 2 3 fclose(fichier); //Liberation memoire fclose(crypt); free(tableau);
Il faudrait faire un free() sur « tableau » si tu l'avais explicitement alloué avec malloc(). Ici, ton tableau est une variable déclarée dans la pile. Si tu passes ça à free(), ça va planter.

Bon courage.

13/07/2010, 12h10
Flynet

Bonjour
-Pour l'inclusion c'est normale je n'ai pas donne le .h car il n'est pas necessaire, il ne contient que le prototype de la fonction. Il en va de meme pour mon main, celui ci ne contient qu'un simple menu avec un switch.

-Pour le nom du pointeur et de la fonction je ne savais pas que c'etait source de probleme. Corrige :ccool:

-Pour les fonctions sur la taille, je vais me renseigner dessus mais le mieux serait que ca soit portable et le code est en C.

-Pour la verification d'erreur je l'avais fait dans le premier code mais j'ai du oublie de l'inclure dans le 2e, desole.

-Pour le /0 je vois ce que tu veux dire je pense que je vais placer le test de l'equivalence avant le XOR.

-pour les dernieres erreurs je m'en excuse en modifiant le premier code j'ai fait quelques petites erreurs d'inattention.:mrgreen:

Bon apres toutes ces modifs j'ai teste de nouveau sur un fichier de 1,7 go environ sur une machine equipee de xp avec 2 go de ram et ca marche !
Le cryptage par contre est un peu lent (2 mn deja passe et encore en train de crypter)...

Je pense que je vais rajouter une fonction permettant de calculer l'avancement du fichier en comparant la taille actuelle a la taille totale.

J'ai juste une derniere question que je n'arrive pas a comprendre. Mon compilateur me fait comprendre qu'il y a une declaration implicite de getch() pourquoi ?

edit : et serait-il possible de diminuer le temps de cryptage ? un fichier de 700 mo prend deja plusieurs minutes...

Merci de ton aide !
13/07/2010, 21h35
Obsidian

Citation:

Envoyé par Flynet

-Pour le nom du pointeur et de la fonction je ne savais pas que c'etait source de probleme. Corrige :ccool:

C'est source de problème au niveau du programmeur uniquement. Ça reste légal tant que c'est volontaire et que tu sais ce que tu fais.

Il faut savoir qu'un nom de fonction, en C, est un symbole comme un autre, qui donc peut être évalué. En l'occurence, « crypt » tout seul est un pointeur vers le code de ta fonction (son point d'entrée, plus précisément). Si ta variable locale n'est pas visible partout, tu risques d'interpréter la mauvaise valeur sans recevoir de message d'erreur.

Citation:

-Pour les fonctions sur la taille, je vais me renseigner dessus mais le mieux serait que ca soit portable et le code est en C.

Lis le fil indiqué, déjà. Il est assez instructif.

Citation:

-pour les dernieres erreurs je m'en excuse en modifiant le premier code j'ai fait quelques petites erreurs d'inattention.:mrgreen:

Oh, tu n'as pas à t'excuser. :-) Tout le monde passe par là. L'essentiel étant de corriger en premier la réouverture systématique d'un fichier à chaque caractère.

Citation:

J'ai juste une derniere question que je n'arrive pas a comprendre. Mon compilateur me fait comprendre qu'il y a une declaration implicite de getch() pourquoi ?

Parce que, contrairement à une idée répandue, getch() n'existe pas en C standard. C'est une fonction Windows déclarée dans conio.h, et que l'on retrouve dans curses. Lorsque ton compilo te dit « déclaration implicite », ça veut dire que tu utilises une fonction dont il ignorait l'existence jusqu'ici. L'utiliser la déclare donc de fait, parce qu'il est tolérant, mais il ne connaît pas sa signature, et suppose donc qu'elle est de type int. Pas terrible, donc.

D'autre part, tu ne peux pas utiliser getch() (pas portable) ni getchar() pour faire une pause au clavier, car rien ne te dit que c'est bien du clavier que proviendront ces caractères. Ils seront lus depuis l'entrée standard, qui peut venir de n'importe où. En outre, sur un terminal UNIX, ou même un terminal distant réel, la frappe au clavier est généralement bufferisée par le terminal ou par une bibliothèque tierce jusqu'à ce que l'utilisateur valide la ligne. Donc taper une touche n'aurait aucun effet au niveau de ton programme.

Citation:

edit : et serait-il possible de diminuer le temps de cryptage ? un fichier de 700 mo prend deja plusieurs minutes...

Reposte la dernière version de ton code. On va regarder ça.
Bon courage.

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
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
 
#include <stdio.h>
#include <stdlib.h>
#include "crypt.h"
 
void crypt()
{
    char chaine[100] = ""; // adresse
    char chaine2[20] = ""; // mot de passe
    FILE *fichier = NULL; // Fichier d'origine
    FILE *crypt = NULL; // fichier cryptÈ
    int taille = 0, j = 0; // Taille pour test d'erreur
    int taille2 = 0;
    char tableau[2] = ""; // tableau de cryptage
//---------------------------------------------------------Var / bases
 
    printf("Placer le fichier a crypter dans le meme dossier que le programme.\n");
    printf("Indiquez son nom (son extension y compris ex : fichier.ext).");
    printf("\nAttention la console ne gere pas les accents et les espaces !!!\n\n");
    scanf("%100s", chaine); // Adresse du fichier
    fichier = fopen(chaine, "rb"); // En mode lecture binaire
    if (fichier == NULL) // Si y a erreur
    {
     printf( "Erreur d'ouverture du fichier." );
     exit( EXIT_FAILURE );
    }
 
    fseek(fichier, 0, SEEK_END);
    taille = ftell(fichier);
    rewind(fichier);
 
    printf("\nDonnez un mot de passe pour crypter : ");
    getchar();
    fgets(chaine2, 19, stdin);
 
    crypt = fopen( "crypt.cr", "wb");
 
//---------------------------------------------------------------CRYPTAGE, LECTURE
while ( ftell(fichier) != taille )
{
    fread( tableau, 1, 1, fichier);
 
//----------------------------------------------------------------- XOR (cryptage)
 
     if ( chaine2[j] == '\0' )
     {
         j = 0;
     }
     else
     {
         j++;
     }
tableau[0] = tableau[0] ^ chaine2[j]; // Fonction XOR
 
//----------------------------------------------------------------- ECRITURE
 
    fwrite( tableau, 1, 1, crypt);
 
 
//----------------------------------------------------------------Progression
 
    taille2 = ftell(crypt);
    taille2 = (taille2 * 100) / taille;
    system("cls");
    printf("Progression : %d pour cent.", taille2);
}
//-----------------------------------------------------------------SUCCES
    printf("\nLe fichier crypte a ete place dans le meme dossier et est nomme \"crypt.cr\".");
    printf("\nAppuyer sur une touche pour continuer");
    getch();
 
    fclose(fichier); //Liberation memoire
    fclose(crypt);
}

Petite precision j'ai volontairement pas verifier l'erreur au niveau du fread et et les fonctions pour la taille. Je verrai ça quand le programme sera fonctionnel.

Pour getch, dois-je inclure conio.h ? Et comment faire en sorte que cela soit portable ? Dois-je utiliser system("pause") ?

J'ai rajouté deux trois lignes pour montrer la progression du cryptage parce-qu'il est vraiment tres lent, mais en plus de ça il ralentis vraiment le cryptage. Je souhaiterai montrer la progression sans pour autant que ça soit trop long.

13/07/2010, 22h29
Mat.M

Salut,

Citation:

Envoyé par Flynet

Un ami m'a expliqué que lorsqu'on fait "fopen" le fichier est chargé en mémoire.

C'est une erreur !
A ma connaissance fopen ne fait qu'ouvrir un "handle" c.a.d un descripteur de fichier.

Citation:

Envoyé par Flynet

Bon apres toutes ces modifs j'ai teste de nouveau sur un fichier de 1,7 go environ sur une machine equipee de xp avec 2 go de ram et ca marche !
Le cryptage par contre est un peu lent (2 mn deja passe et encore en train de crypter)...

je déconseille d'utiliser les fonction standards du C tu ne pourras pas décider d'une stratégie de gestion de mémoire.
Il vaut mieux utiliser les API win32 comme GlobalAlloc,VirtualAlloc() etc...

Citation:

edit : et serait-il possible de diminuer le temps de cryptage ? un fichier de 700 mo prend deja plusieurs minutes...

Merci de ton aide !

C'est une autre problématique: sous Windows il vaut mieux passer à la programmation en multithreading...
en win32 par exemple tu peux définir sur quel CPU peut tourner un thread et faire du traitement en parallèle sur un n core ce qui peut optimiser le programme et le faire tourner plus rapidement.
Visual Studio 2010 intégre la programmation parallèle et des directives de précompilation pour cela.

Maintenant avant de sortir la grosse artillerie :aie:, peut-être il y a t-il des optimisations et des goulots d'étranglements dans ton code il faut utiliser un "Profiler" au besoin..
14/07/2010, 09h48
Flynet

Je ne connais malheuresement pas encore les api et en ce qui concerne le multi-threading non plus. Lequel me conseilles-tu de commencer avec ?
Même si pour l'instant j'utilise codeblocks, je peux toujours me mettre a la programmation en parallele ?

Et qu'appelles-tu "profiler" ?

Et je reprends pour getch, comment enlever l'avertissement et avoir un code portable ?

merci
14/07/2010, 11h52
Invité

Bonjour,
Pour que le programme attende la frappe d'une touche de clavier, l'instruction

Code:

while (!kbhit());

est aussi peu portable que getch(), mais un peu plus jolie.
Pour tester la frappe d'une touche sous UNIX, il y a eu dernièrement ce sujet qui l'a largement traité http://www.developpez.net/forums/d94...ue-lexecution/
Cordialement.
14/07/2010, 15h33
Mat.M

Citation:

Envoyé par Flynet

Je ne connais malheuresement pas encore les api et en ce qui concerne le multi-threading non plus. Lequel me conseilles-tu de commencer avec ?
Même si pour l'instant j'utilise codeblocks, je peux toujours me mettre a la programmation en parallele ?

Aie cela va être dur ! :lol:
oui si codeblocks supporte les API win32 aucun problème pour faire de la programmation parallèle..
mais ce sera au niveau API win32 seulement pas au niveau de l'optimisation du code.
Pour obtenir des blocs de code optimisés il faut avoir recours à Thread Building blocks d'Intel par exemple qui est Open Source je crois ( mais qui ne fonctionne qu'avec les CPU Intel évidemment ).

Mais le plus simple c'est d'utiliser une bibliothèque comme pthread qui est portable

Citation:

Et qu'appelles-tu "profiler" ?

un profiler c'est une fonctionnalité du compilateur : en exécution tu peux inspecter une ou des fonctions et voir le temps d'exécution qu'elles mettent pour faire un traitement.
Voir l'aide de CodeBlocks
Mais je te conseille d'essayer d'optimiser ton code avant : éviter les boucles imbriquées par exemple

Bonjour,

Citation:

Envoyé par Flynet

Petite precision j'ai volontairement pas verifier l'erreur au niveau du fread et et les fonctions pour la taille. Je verrai ça quand le programme sera fonctionnel.

Alors, au moins, modifie quelque peu la ligne ou tu appelles ftell() dans ta boucle :

Code:

while ( ftell(fichier) != taille )

Remplace déjà « != » par « < », car le curseur d'un fichier peut-être artificiellement placé après sa fin. D'autre part, en cas d'erreur, ftell() peut renvoyer « -1 » et il faut que tu gères ce cas aussi. Le plus propre étant de renvoyer « vrai » si 0 ≤ ftell() < taille.

Citation:

Pour getch, dois-je inclure conio.h ? Et comment faire en sorte que cela soit portable ? Dois-je utiliser system("pause") ?

Il faut include <conio.h> uniquement si tu travailles sous Windows et que tu tiens à utiliser cette fonction (absolument pas portable, donc). Surtout pas « system("pause") » car, là, tu sors carrément du langage C, et tu demandes au Shell d'appeler pour toi une commande ou un exécutable appelé « pause ». Rien ne te garantit qu'il existe, d'une part, et rien ne te garantit non plus que soit celui que tu cherches, d'autre part.

Le problème est que l'appui sur une touche n'est pas du tout portable en soi car tu n'es même pas sûr que le programme soit lancé par un utilisateur (il peut l'être par un autre programme) ni que la machine en question soit dotée d'un clavier.

Sous Unix, après t'être assuré que l'entrée standard est bien reliée à un terminal, tu peux configurer celui-ci pour que tous les caractères te soient envoyés immédiatement. Tu peux ensuite les lire en toute sécurité avec getchar() (et non getch()).

Je pense que le plus simple et le plus portable à la fois, dans un premier temps, est d'utiliser fgets(), tout simplement, et de demander à l'utilisateur de taper Entrée plutôt qu'une touche quelquonque.

Citation:

J'ai rajouté deux trois lignes pour montrer la progression du cryptage parce-qu'il est vraiment tres lent, mais en plus de ça il ralentis vraiment le cryptage. Je souhaiterai montrer la progression sans pour autant que ça soit trop long.

Ton programme est archi-lent parce que tu lis et écris tes caractères un par un. Et encore, les fonctions en f.... passent par une bibliothèque qui limite les appels aux noyaux et tient ses propres buffers. Si tu faisais, à la place, des appels système et que tu n'avais pas de cache disque, étant donné que tu lis un caractère depuis un fichier et l'écris immédiatement dans un autre, non seulement ce serait très lent mais ton disque dur souffrirait beaucoup (il ferait sans arrêt l'aller-retour entre les deux fichiers).

Déclare à la place un buffer assez grand (1 Mo, par exemple) avec malloc(). Charge-le d'un coup avec fread() en relevant le nombre exact de caractères qui t'es retourné par cette fonctions (tes fichiers ont de bonnes chances d'être moins gros que cela). Crypte l'intégralité des n caractères lus directement dans le buffer. Puis écris ces n caractères modifiés en une fois dans le fichier de sortie avec fwrite(). Enfin, tu recommences si et seulement si le nombre de caractères que tu as lus et traités est égal à la taille du buffer (sinon, fin de fichier atteinte ou erreur).

Dernière remarque :
Code:

1 2 3 4 5 6 //----------------------------------------------------------------Progression taille2 = ftell(crypt); taille2 = (taille2 * 100) / taille; system("cls"); printf("Progression : %d pour cent.", taille2);
Un ftell() à cet endroit est coûteux et inutile : étant donné que c'est toi qui écrit les caractères en sortie, tu peux très bien en tenir le compte toi-même avec une variable « count++ ».

Enfin, de toutes les actions que tu effectues, « system("cls") » est probablement la plus lente. Désactive ce bloc en entier et je suis sur que tu vas accélérer ton programme d'un facteur 10.

Citation:
Envoyé par Obsidian
Dernière remarque :
Code:

1 2 3 4 5 6 //----------------------------------------------------------------Progression taille2 = ftell(crypt); taille2 = (taille2 * 100) / taille; system("cls"); printf("Progression : %d pour cent.", taille2);
Un ftell() à cet endroit est coûteux et inutile : étant donné que c'est toi qui écrit les caractères en sortie, tu peux très bien en tenir le compte toi-même avec une variable « count++ ».
D'une manière générale, tout les ftell() dans ce code sont inutiles, autant utiliser directement la valeur de retour de fread() pour gérer la boucle.

Entièrement d'accord concernant l'appel à cls et d'une manière générale l'affichage de la progression, c'est probablement ce qui prends le plus de temps.

14/07/2010, 21h37
Obsidian

Citation:

Envoyé par gl

D'une manière générale, tout les ftell() dans ce code sont inutiles, autant utiliser directement la valeur de retour de fread() pour gérer la boucle.

C'est vrai, mais on a déjà traité le cas des deux premiers :

Citation:

Envoyé par Obsidian

C'est effectivement le (seul ?) moyen de le faire si on veut s'en tenir au C standard et faire quelque chose d'universellement portable. Pourtant, ce n'est pas forcément la meilleure solution. stat() ou GetFileSize() sous Windows seraient plus appropriés, comme débattu sur ce fil.

Citation:

Envoyé par Flynet

Petite precision j'ai volontairement pas verifier l'erreur au niveau du fread et et les fonctions pour la taille. Je verrai ça quand le programme sera fonctionnel.
15/07/2010, 10h29
Flynet

Je ne connaissais pas "kbhit()", mais d'apres ce que j'ai vu, il ne fait pas non plus partie des standarts du C. Et je pense qu'Obsidian a raison, qu'il vaut mieux utiliser fgets.

Pour Mat.M, je vais me renseigner sur le profiler de codeblocks, et je crois que le plus simple est de passer aux api.

Pour revenir au ftell d'obsidian, ne vaut-il mieux pas verifier que ftell renvoie bien la taille et non qu'il soit aller plus loin ? J'ai pas tres bien compris cette histoire de curseur place artificiellement apres:?

Ensuite, je ne connais pas vraiment ce que sont les appels systemes ni le cache disque, je ne peux donc pas faire grand chose a ce niveau la. Mais en ce qui concerne la taille du buffer, je l'ai mis a 1 octet car je me suis dis que si mon fichier en faisait 23 par exemple et que si je lisais par exemple 5 par 5, il y aurait 2 octets en plus qui ne correspondent pas au fichier... Comme tu l'as dit pour un fichier inferieur a 1 mo.
Et pourquoi utiliser malloc quand on connait la taille exacte du buffer(dans ce cas 1 mo) ?

(jespere que quand tu parlais du buffer c'etait la taille du tableau et du nombre d'octet lu par fread :mrgreen:, sinon bah je crois qu'il y a une fonction pour modifier le buffer aussi)

Citation:

(sinon, fin de fichier atteinte ou erreur).

Cette phrase m'a fait tiquee, je pense que pour le probleme precedent je vais faire comme tu m'a dit c'est-a-dire recuperer a chaque fois le nombre de caracteres lus par fread et comparer a la fin a la taille du fichier. Mais je me demande juste si le fichier fait moins que le buffer, est-ce que fread va s'arreter a la taille ou continuer a lire 1mo ?

Pour le bloc sur la progression, je comprends ce que tu veux dire pour la variable. Cependant si je veux afficher la progression, comment le faire sans 'cls' ? J'aurais des milliers de printf si mon fichier est gros.

Citation:

D'une manière générale, tout les ftell() dans ce code sont inutiles, autant utiliser directement la valeur de retour de fread() pour gérer la boucle.

Euh tout mon code ou juste la partie de la progression ? Je ne pense pas pouvoir savoir la fin de mon fichier si je connais pas sa taille sans bien sur regarder de plus pres les fonctions proposees par Obsidian. Sinon tu as raison le mieux est de gerer la progression avec fread.

Et encore d'accord avec toi l'affichage de la progression est ce qui prend le plus de temps, mais si le fichier prend du temps a etre crypte comment indiquer a l'utilisateur s'il faut encore attendre longtemps ?

Merci vraiment pour vos reponses, j'ai appris beaucoup de choses mine de rien.
15/07/2010, 13h24
Obsidian

Citation:

Pour revenir au ftell d'obsidian, ne vaut-il mieux pas verifier que ftell renvoie bien la taille et non qu'il soit aller plus loin ?

Non. Tu te sers de ftell() dans ta boucle, pour savoir si tu as bien atteint la fin de ton fichier. En utilisant « != » plutôt que « < », si pour une raison ou une autre tu dépasses cette limite, alors ton programme ne s'arrêtera jamais et tu vas saturer ton disque.

Citation:

J'ai pas tres bien compris cette histoire de curseur place artificiellement apres:?

La fonction fseek() te permet de te déplacer après la fin du fichier, si nécessaire, de manière à faire des mouvements relatifs. Si tu fais une opération d'écriture à ce moment-là, l'espace vide entre la fin du fichier et la position où tu te trouves sera comblée par des zéros (sous Linux, en tout cas, je ne sais pas si c'est dans la norme ou pas).

Citation:

Ensuite, je ne connais pas vraiment ce que sont les appels systemes ni le cache disque, je ne peux donc pas faire grand chose a ce niveau la. Mais en ce qui concerne la taille du buffer, je l'ai mis a 1 octet car je me suis dis que si mon fichier en faisait 23 par exemple et que si je lisais par exemple 5 par 5, il y aurait 2 octets en plus qui ne correspondent pas au fichier... Comme tu l'as dit pour un fichier inferieur a 1 mo.

Ce n'est pas recevable car tu n'es pas obligé d'écrire la totalité du buffer. Un buffer est un espace tampon qui permet de faire des opérations sur une certaine quantité de données d'un coup. Si la quantité de données totale excède la taille de ce buffer, alors il faut faire plusieurs opérations, mais ce n'est pas la taille du buffer qui détermine ce que tu vas écrire (en tout cas, pas à ton niveau. Ça peut avoir de l'intérêt avec les raw devices, par exemple, mais tu n'en es pas là).

C'est exactement comme louer un camion pour déménager : tu vas remplir ta remorque à ras-bord, mais tu devras quand même faire plusieurs voyages. Au dernier voyage, le peu qu'il restera ne remplira que la moitié de ta remorque.

Citation:

Et pourquoi utiliser malloc quand on connait la taille exacte du buffer(dans ce cas 1 mo) ?

Parce l'espace d'un tableau déclaré comme une variable locale est réservé dans la PILE, dont il faut économiser l'espace autant que faire se peut. Un Mo, c'est déjà trop, mais le système te laissera le faire quand même. Au delà, il se peut que ton programme ne démarre même pas.

Voir, par exemple, cette discussion.

Citation:

Cette phrase m'a fait tiquee, je pense que pour le probleme precedent je vais faire comme tu m'a dit c'est-a-dire recuperer a chaque fois le nombre de caracteres lus par fread et comparer a la fin a la taille du fichier. Mais je me demande juste si le fichier fait moins que le buffer, est-ce que fread va s'arreter a la taille ou continuer a lire 1mo ?

Tu n'as pas besoin de comparer « à la fin avec taille du fichier » : si, à un moment donné, la quantité de données lues est inférieure à la taille du buffer, c'est qu'il n'y a plus rien à lire et, donc, que tu as fini.

C'est l'idée : si tu as demandé à fread() de lire n octets (plus précisément n éléments longs de un octet) et qu'il t'annonce en avoir lu moins, c'est qu'il s'est forcément arrêté ! Et il n'y a que deux raisons qui puisse le pousser à le faire, la fin du fichier ou une erreur à la lecture.

Citation:

Pour le bloc sur la progression, je comprends ce que tu veux dire pour la variable. Cependant si je veux afficher la progression, comment le faire sans 'cls' ? J'aurais des milliers de printf si mon fichier est gros.

À toi de faire en sorte que cela ne se produise qu'occasionnellement. Tu affiches un pourcentage. Si tu fais fi des décimales, alors tu n'as besoin de mettre l'affichage à jour que 100 fois pour tout le processus.

Donc, tu prends la taille de ton fichier, tu la divises par cent, et tu obtiens le nombre d'octets qu'il faut laisser passer avant de refaire une mise à jour.

Citation:

Euh tout mon code ou juste la partie de la progression ? Je ne pense pas pouvoir savoir la fin de mon fichier si je connais pas sa taille sans bien sur regarder de plus pres les fonctions proposees par Obsidian. Sinon tu as raison le mieux est de gerer la progression avec fread.

C'est la manière normale de gérer les fichiers en C.

Citation:

Et encore d'accord avec toi l'affichage de la progression est ce qui prend le plus de temps, mais si le fichier prend du temps a etre crypte comment indiquer a l'utilisateur s'il faut encore attendre longtemps ?

C'est pas le XOR qui va te prendre du temps CPU :mrgreen: En tout état de cause, ton unité de mesure est l'octet puisque tu fais une boucle pour les lire, les traiter et les écrire un par un. Quelque soit le temps que cela prend, ton pourcentage est une proportions d'octets déjà traités. C'est cette quantité qu'il faut mesurer.

Si tu veux faire quelque chose APRÈS avoir écrit le dernier octet, que cette chose doit prendre du temps et que tu veux l'inclure dans ta barre de progression, il n'y a pas de secret : c'est de la planification comme tu le ferais pour un projet dans la vie réelle. Tu dois estimer à l'avance le temps que cela va prendre et le traduire en « nombre d'octets ». Et ce n'est pas facile. Nombreuses sont (spécialement sous l'OS de Redmond), les barres de progressions qui figent à 99%.

Bonjour,

J'ai seulement remplacer la taille du buffer par 1 mo au lieu de 1 octet et effectivement le cryptage est plus rapide. A partir de la deja une remarque :
le fichier crypte fais a present 1 mo, celui d'origine un fichier texte de seulement 13 octet. J'ai essayer de l'ouvrir avec notepad++ et effectivement obsidian avait raison, la fin a ete remplie avec des caracteres NULL. Petite question, est-il possible d'eviter a fwrite d'ecrire des donnes supplementaires qui n'ont rien a voir avec le fichier ? (Bon 1 mo de plus c'est pas beaucoup mais on sait jamais si je decider de mettre plus)

Ensuite bah la c'est mon decryptage qui bloque au niveau de la boucle qui ne finit jamais et je comprends pas pourquoi. Voici le crypteur :

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
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
#include <stdio.h>
#include <stdlib.h>
#include "crypt.h"
 
#define BUFFER 1048576
 
void crypt()
{
    char chaine[100] = ""; // adresse
    char pass[20] = ""; // mot de passe
    FILE *fichier = NULL; // Fichier d'origine
    FILE *crypt = NULL; // fichier crypté
    int taille = 0, i = 0, j = 0; // Taille pour test d'erreur
    char *tableau; // tableau de cryptage
//---------------------------------------------------------------------------------------------------------------------------------------------- Var / bases
 
    printf("Placer le fichier a crypter dans le meme dossier que le programme.\n");
    printf("Indiquez son nom (son extension y compris ex : fichier.ext).");
    printf("\nAttention la console ne gere pas les accents et les espaces !!!\n\n");
 
    scanf("%100s", chaine); // Adresse du fichier
 
    fichier = fopen(chaine, "rb"); // En mode lecture binaire
    if (fichier == NULL) // Si y a erreur
    {
     printf( "Erreur d'ouverture du fichier." );
     exit( EXIT_FAILURE );
    }
 
    fseek(fichier, 0, SEEK_END); // taille du fichier
    taille = ftell(fichier);
    rewind(fichier);
 
    tableau = malloc ( (BUFFER + 1) * sizeof(char) );
 
    printf("\nDonnez un mot de passe pour crypter : ");
    getchar();
    fgets(pass, 19, stdin);
 
    crypt = fopen( "crypt.cr", "wb");
 
//------------------------------------------------------------------------------------------------------------------------------------------------ CRYPTAGE, LECTURE
while ( ftell(fichier) < taille ) // au cas ou je me retrouve apres
{
    fread( tableau, BUFFER, 1, fichier);
 
//--------------------------------------------------------------------------------------------------------------------------------------------------- XOR (cryptage)
i = 0;
 
while( tableau[i] != '\0' )
{
     if ( pass[j] == '\0' )
     {
         j = 0;
     }
     else
     {
         j++;
     }
tableau[i] = tableau[i] ^ pass[j]; // Fonction XOR
i++;
}
//--------------------------------------------------------------------------------------------------------------------------------------------------- ECRITURE
 
    fwrite( tableau, BUFFER, 1, crypt);
 
 
//-----------------------------------------------------------------------------------------Progression
 
    /*taille2 = ftell(crypt);
    taille2 = (taille2 * 100) / taille;
    system("cls");
    printf("Progression : %d pour cent.", taille2);*/
}
//----------------------------------------------------------------------------------------------------------------------------------------------------- SUCCES
    printf("\nLe fichier crypte a ete place dans le meme dossier et est nomme \"crypt.cr\".");
    printf("\nAppuyer sur une touche pour continuer");
    while (!kbhit());
 
    free(tableau);
    fclose(fichier); //Liberation memoire
    fclose(crypt);
}

Et le decrypteur :

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
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
#include <stdio.h>
#include <stdlib.h>
#include "decrypt.h"
 
#define BUFFER 1048576
 
void decrypt()
{
    char ext[4] = "";
    char chaine[25] = "fichier decrypte";
    char pass[20] = "";
    FILE *fichier = NULL; // Fichier d'origine
    FILE *decrypt = NULL; // fichier crypté
    int taille = 0, i = 0, j = 16; // Taille pour malloc
    char *tableau;
 
//--------------------------------------------------------------------------------------------------------------------------------------------- VAR / BASES
 
    printf("Placer le fichier \"crypt.cr\" dans le meme dossier que le programme.\n");
    printf("Quand c'est fait appuyez sur une touche.\n");
    getch();
 
    fichier = fopen("crypt.cr", "rb"); // En mode lecture binaire
    if (fichier == NULL) // Si y a erreur
    {
     printf( "Erreur d'ouverture du fichier." );
     exit( EXIT_FAILURE );
    }
 
    printf("Rentrer le mot de passe pour decrypter : ");
    getchar();
    fgets(pass, 19, stdin);
 
    fseek( fichier, 0, SEEK_END); // La taille pour le malloc
    taille = ftell( fichier );
    rewind( fichier );
 
    printf("\nQuel est l'extension d'origine ? ( ex : .exe, .jpg, ...etc)");
    scanf("%4s", ext);
 
    for ( i = 0; ext[i] != '\0'; i++)
{
    chaine[j] = ext[i];
    j++;
}
 
decrypt = fopen( chaine, "wb");
j = 0;
//--------------------------------------------------------------------------------------------------------------------------------------------- DECRYPTAGE, LECTURE
 
while( ftell(fichier) < taille)
{
    fread( tableau, BUFFER, 1, fichier);
 
 
//--------------------------------------------------------------------------------------------------------------------------------------------- XOR (decryptage)
i = 0;
while(tableau[i] != '\0')
{
     if( pass[j] == '\0')
     {
         j = 0;
     }
 
     else
     {
         j++;
     }
 
tableau[i] = tableau[i] ^ pass[j];
i++;
}
//--------------------------------------------------------------------------------------------------------------------------------------------- ECRITURE
 
    fwrite( tableau, BUFFER, 1, decrypt);
}
//--------------------------------------------------------------------------------------------------------------------------------------------- SUCCES
 
printf("\nLe fichier a ete correctement decrypte et a ete place dans le meme dossier.\n");
printf("Il a pour nom : \"fichier decrypte\"");
printf("\nAppuyer sur une touche pour continuer.");
getch();
 
    free(tableau);
    fclose(fichier);
    fclose(decrypt);
 
}

16/07/2010, 15h37
gl

Citation:

Envoyé par Flynet

J'ai seulement remplacer la taille du buffer par 1 mo au lieu de 1 octet et effectivement le cryptage est plus rapide. A partir de la deja une remarque :
le fichier crypte fais a present 1 mo, celui d'origine un fichier texte de seulement 13 octet. J'ai essayer de l'ouvrir avec notepad++ et effectivement obsidian avait raison, la fin a ete remplie avec des caracteres NULL. Petite question, est-il possible d'eviter a fwrite d'ecrire des donnes supplementaires qui n'ont rien a voir avec le fichier ?

Oui, il ne faut pas demander à fwrite() d'écrire le nombre de caractère pouvant être contenu dans le buffer, donc BUFFER ici (qui au passage est un mauvais choix pour nommer une taille) mais le nombre de caractère réellement utiles, c'est à dire le nombre de caractères lus par fread() (qui est la valeur de retour de fread()).

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