Copie d'un exe dans une chaine de caractère

**Jupiter41** · 03/01/2018, 09h08

Salut sa marche parfaitement avec ce code ! :

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
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
89
90
91
92
93
94
95
96
97
 
#include <stdio.h>
#include <stdlib.h>
#include <libgen.h>
#include <string.h>
#include <dirent.h>
#include <stdbool.h>
 
int main(int argc, char *argv[]) {
 
    char *name = basename(argv[0]) ; //Récupère le nom du fichier
 
    FILE *fd ;
 
    fd = fopen(name, "rb");
 
    int longueur_fd = 0 ;
 
    char caractere ;
 
    while (fread(&caractere, 1, 1, fd) == 1) longueur_fd++ ;
 
    if (ferror(fd)) {
 
        perror("fread") ;
 
        exit(EXIT_FAILURE);
 
    }
 
    char *copyActualFile = malloc (sizeof(char) * (longueur_fd + 1)) ;
 
    rewind(fd) ;
 
    caractere = 0 ;
 
    int i ;
 
    for (i = 0 ; fread(&caractere, 1, 1, fd) == 1 ; i++) copyActualFile[i] = caractere ;
 
    copyActualFile[i+1] = '\0' ;
 
    FILE *fd2 ;
 
    fd2 = fopen ("test.exe", "rb") ;
 
    int longueur_fd2 = 0 ;
 
    caractere = 0 ;
 
    while (fread(&caractere, 1, 1, fd2) == 1) longueur_fd2++ ;
 
    if (ferror(fd2)) {
 
        perror("fread") ;
 
        exit(EXIT_FAILURE);
 
    }
 
    char *copyOtherFile = malloc (sizeof(char) * (longueur_fd2 + 1)) ;
 
    rewind(fd2) ;
 
    caractere = 0 ;
 
    for (i = 0 ; fread(&caractere, 1, 1, fd2) == 1 ; i++) copyOtherFile[i] = caractere ;
 
    copyOtherFile[i+1] = '\0' ;
 
    int ret = 0 ;
 
    if (longueur_fd > longueur_fd2) ret = memcmp(copyActualFile, copyOtherFile, (size_t) longueur_fd) ;
 
    else ret = memcmp(copyActualFile, copyOtherFile, (size_t) longueur_fd2) ;
 
    if (ret < 0) printf("copyActualFile is less than copyOtherFile") ;
 
    else if (ret < 0) printf ("copyOtherFile is less than copyActualFile") ;
 
    else printf ("copyActualFile is equals to copyOtherFile") ;
 
    system ("pause") ;
 
    //Fermeture
 
    free(copyActualFile) ;
 
    free (copyOtherFile) ;
 
    fclose(fd) ;
 
    fclose(fd2) ;
 
    return EXIT_SUCCESS ;
 
}

J'aimerais néanmoins savoir si il existe une autre fonction qui serait "identique" à strstr() -> C'est à dire qui fonctionnerais si seulement une partie des 2fichiers et identiiques

**Matt_Houston** · 03/01/2018, 10h45

Ce code..

On commence par quoi : la gestion d'erreur absente, le dépassement de capacité, l'inconstance (ici on lit avec un while, là avec un for..), l'erreur de logique ?

Envoyé par Jupiter41

Code :

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

1
2
3
    char caractere ;
 
    while (fread(&caractere, 1, 1, fd) == 1) longueur_fd++ ;

=>

Envoyé par liberal1

Un fichier binaire est composé d'octets et pas de caractère.
Un fichier binaire est composé d'octets et pas de caractère.
Un fichier binaire est composé d'octets et pas de caractère.
Un fichier binaire est composé d'octets et pas de caractère.

Envoyé par dalfab

Un fichier binaire est composé d'octets et pas de caractère.
Un fichier binaire est composé d'octets et pas de caractère.
Un fichier binaire est composé d'octets et pas de caractère.

Just sayin'..

Envoyé par Jupiter41

J'aimerais néanmoins savoir si il existe une autre fonction qui serait "identique" à strstr() -> C'est à dire qui fonctionnerais si seulement une partie des 2fichiers et identiiques

Définis « si seulement une partie des 2fichiers et identiiques »..

**Jupiter41** · 03/01/2018, 11h46

-La gestion d'erreur est absente car le but serait de l'intégrer dans un autre programme et que l’absence d'un fichier par exemple est impossible
-Voir le premier '-' (c'est pour l'intégrer) c'est juste que j'ai déjà une variable nommé caractère mais je modifierais, c'est un oublie.
-C'est clair il me semble, si tu ne comprends pas je veux trouvé une fonction comme strstr (comme je l'ai dit)

**Jupiter41** · 03/01/2018, 12h16

J'ai trouver la fonction memmem(), CodeBlock ne la connaissait pas, j'ai donc trouve le code de celle-ci :

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
void *memmem(const void *haystack, size_t hlen, const void *needle, size_t nlen)
{
    int needle_first;
    const void *p = haystack;
    size_t plen = hlen;
 
    if (!nlen)
        return NULL;
 
    needle_first = *(unsigned char *)needle;
 
    while (plen >= nlen && (p = memchr(p, needle_first, plen - nlen + 1)))
    {
        if (!memcmp(p, needle, nlen))
            return (void *)p;
 
        p++;
        plen = hlen - (p - haystack);
    }
 
    return NULL;
}

Et sa marche impec' ! Merci beaucoup pour votre aide !

**liberal1** · 03/01/2018, 21h38

Quelques remarques :

Code :

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

1
2
3
int main(int argc, char *argv[]) {
 
    char *name = basename(argv[0]) ; //Récupère le nom du fichier

argv[0] est le nom de ton exécutable, pas un paramètre supplémentaire.

Code :

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

1
2
3
4
5
    while (fread(&caractere, 1, 1, fd) == 1) longueur_fd++ ;
(...)
    char *copyActualFile = malloc (sizeof(char) * (longueur_fd + 1)) ;
(...)
    char *copyOtherFile = malloc (sizeof(char) * (longueur_fd2 + 1)) ;

1) Pourquoi utiliser sizeof(char) ici?

D'abord sizeof(char) vaut 1 par définition. Pas par accident.

Ensuite, si jamais tu penses que tu vas un jour remplacer char par un autre type (dont la taille ne serait pas 1), tu devrais :
- utiliser un typedef
ou bien
- utiliser sizeof caractere

et surtout, tu devrais être systématique et utiliser sizeof partout.

2) Pourquoi (longueur_fd + 1) et pas longueur_fd?

À quoi pourrait servir l'octet supplémentaire?

**Jupiter41** · 04/01/2018, 12h36

-Je sais

mais je suis sur Windows, donc argv[0] contient le chemin complet vers mon programme alors que je veux seulement "nom.exe"
-Pour me souvenir du prototypes de la fonction ^^
-Pour le caractère '\0' que je rajoute après

**liberal1** · 04/01/2018, 16h09

Envoyé par Jupiter41

-Pour le caractère '\0' que je rajoute après

Oui, je comprends.

Mais rajouter '\0' pour quoi faire?

**Jupiter41** · 04/01/2018, 22h25

J'imagine que sa ne sert à rien ? :p (c'était parce que c'est une chaîne de caractère ^^)

**liberal1** · 04/01/2018, 23h49

Exactement, cela ne sert à rien une fois que tu as compris que
1) tu ne vas pas traiter un fichier comme une "string" (chaine de caractères)
2) tu ne vas pas ajouter un octet de valeur 0 (un char de valeur '\0') à la fin

**Jupiter41** · 05/01/2018, 09h08

Ouais ^^ mais je pensais que même si je ne la traitais pas comme un string il fallait rajouter un '\0' car je l'avais déclarer comme tel (char *)

**ternel** · 05/01/2018, 13h58

C'est que tu n'as pas compris que char* n'est pas le type des chaines de caractères.
C'est le type des pointeurs de char.

Il s'avère que les chaines de caractères sont des suites de char dont la fin est marquée par '\0', et dont le début est effectivement un char*.

**Jupiter41** · 05/01/2018, 15h53

Ok et merci pour ces informations !

**liberal1** · 05/01/2018, 21h46

Attention à ne pas confondre caractère mono-byte et byte.

En C normalisé, le type char représente un byte, l'unité élémentaire adressable de la mémoire (la mémoire qui contient les données, pas le code exécutable). Le type unsigned char peut être utilisé aussi pour représenter le byte et certaines personnes préfèrent cette variante non signée.

En pratique un byte est un octet sur tous les ordinateurs que tu manipules (aussi bien ton PC que ton ordiphone, etc.).

Un pointeur sur un type T peut représenter :
- l'adresse d'un objet unique
- l'adresse du premier élément d'un tableau
- l'adresse du élément dans un tableau
...

Bien sûr les chaines de caractères mono-bytes sont représentées par un pointeur sur un (unsigned) char.

La signification du type pointeur est fondamentalement dépendante du contexte en C (comme en C++).

**Jupiter41** · 06/01/2018, 10h43

D'accord merci beaucoup pour ces précisions !

**ternel** · 08/01/2018, 09h15

La raison pour laquelle les gens utilisent le unsigned char avec les bytes, c'est parce que c'est le type dont le comportement est le plus cohérent avec l'arithmétique attendue.
Notamment pour les opérateurs >> et |.

Le C fournit quelques garanties à son sujet, qui ne sont pas présentes pour le char ou le signed char.

**liberal1** · 08/01/2018, 09h30

Oui les entiers non signés se comportent tous en arithmétique modulo 2^n où n est le nombre de bits.

Le décalage à droite de x bits est équivalent à une division par 2^x.

Copie d'un exe dans une chaine de caractère

C

Discussions similaires

Partager

Partager