Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
cLx
On 22/08/2013 20:36, Matt... wrote:
Bonjour,
J'ai la fonction suivant qui copie un fichier d'un endroit vers un autre. Apparemment il y a un soucis quelque part car la taille de certains fichiers est différente avant et après ???
do { } while(taille == TAILLE_BUFFER_COPY); est très très moche.
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.
Donc à la fin du fichier, taille != TAILLE_BUFFER_COPY et les derniers octets ne sont pas écrits.
J'aurais tendance a faire : while (taille = fread(buffer, sizeof(char), TAILLE_BUFFER_COPY, fps); fwrite(buffer, sizeof(char), taille, fpd); }
(sûrement pas du tout blindé)
On 22/08/2013 20:36, Matt... wrote:
Bonjour,
J'ai la fonction suivant qui copie un fichier d'un endroit vers un autre.
Apparemment il y a un soucis quelque part car la taille de certains fichiers
est différente avant et après ???
http://mirabon.free.fr/dev/copier.txt
avec TAILLE_BUFFER_COPY = 1024
Merci pour vos réponses,
Bertrand.
Outch l'indentation...
do { } while(taille == TAILLE_BUFFER_COPY); est très très moche.
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.
Donc à la fin du fichier, taille != TAILLE_BUFFER_COPY et les derniers octets
ne sont pas écrits.
J'aurais tendance a faire :
while (taille = fread(buffer, sizeof(char), TAILLE_BUFFER_COPY, fps);
fwrite(buffer, sizeof(char), taille, fpd);
}
J'ai la fonction suivant qui copie un fichier d'un endroit vers un autre. Apparemment il y a un soucis quelque part car la taille de certains fichiers est différente avant et après ???
do { } while(taille == TAILLE_BUFFER_COPY); est très très moche.
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.
Donc à la fin du fichier, taille != TAILLE_BUFFER_COPY et les derniers octets ne sont pas écrits.
J'aurais tendance a faire : while (taille = fread(buffer, sizeof(char), TAILLE_BUFFER_COPY, fps); fwrite(buffer, sizeof(char), taille, fpd); }
do { } while(taille == TAILLE_BUFFER_COPY); est très trè s moche.
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 retu rn value is a short item count (or zero).
fread() does not distinguish between end-of-file and error, and caller s must use feof(3) and ferror(3) to determine which occurred.
do { } while(taille == TAILLE_BUFFER_COPY); est très trè s moche.
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 retu rn
value is a short item count (or zero).
fread() does not distinguish between end-of-file and error, and caller s
must
use feof(3) and ferror(3) to determine which occurred.
do { } while(taille == TAILLE_BUFFER_COPY); est très trè s moche.
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 retu rn value is a short item count (or zero).
fread() does not distinguish between end-of-file and error, and caller s must use feof(3) and ferror(3) to determine which occurred.
le 22/08/2013 à 20:36, Matt... a écrit dans le message :
J'ai la fonction suivant qui copie un fichier d'un endroit vers un autre. Apparemment il y a un soucis quelque part car la taille de certains fichiers est différente avant et après ???
Je ne vois pas pourquoi tu n'obtiens pas le même résultat.
Par contre : - par définition sizeof(char) == 1 - tu retournes true même si tes lectures/écritures se passent mal (tu vérifies juste que tu as pu ouvrir les fichiers).
Tu devrais vérifier que tes écritures comportes le même nombre de bytes que la lecture.
Tu devrais vérifier à la fin de ton do { } while () que tu es bien à la fin du fichier avec feof() ou qu'il n'y a pas d'erreur avec ferror().
-- Benoit Izac
Bonjour,
le 22/08/2013 à 20:36, Matt... a écrit dans le message
<op.w18dzqhu0ht7go@gribouille> :
J'ai la fonction suivant qui copie un fichier d'un endroit vers un
autre. Apparemment il y a un soucis quelque part car la taille de
certains fichiers est différente avant et après ???
http://mirabon.free.fr/dev/copier.txt
avec TAILLE_BUFFER_COPY = 1024
Pourquoi ne postes-tu pas ton code ici plutôt que d'obliger tes lecteurs
à aller voir ton lien ? Tu aurais sans doute plus de réponses...
Je le remets (réindenté) :
----------------------------------------------------------------------------
bool copieFichier(const char *szFichierSrc, const char *szFichierDst)
{
bool ret = false;
char buffer[TAILLE_BUFFER_COPY] = {0};
// Test sur les chaines en entrees
if (szFichierSrc == NULL)
{
writeLog(true, CRITICAL, "Le chemin du fichier source est NULLn");
return ret;
}
if(szFichierDst == NULL)
{
writeLog(true, CRITICAL,
"Le chemin du fichier destination est NULLn");
return ret;
}
// Ouverture du fichier pour la lecture
FILE *const fps = fopen (szFichierSrc, "rb");
if (fps != NULL)
{
// Ouverture du fichier pour l'ecriture
FILE *const fpd = fopen (szFichierDst, "wb");
if (fpd != NULL)
{
size_t taille = 0;
ret = true;
do {
taille = fread(buffer, sizeof(char), TAILLE_BUFFER_COPY, fps);
fwrite(buffer, sizeof(char), taille, fpd);
} while (taille == TAILLE_BUFFER_COPY);
Je ne vois pas pourquoi tu n'obtiens pas le même résultat.
Par contre :
- par définition sizeof(char) == 1
- tu retournes true même si tes lectures/écritures se passent mal
(tu vérifies juste que tu as pu ouvrir les fichiers).
Tu devrais vérifier que tes écritures comportes le même nombre de bytes
que la lecture.
Tu devrais vérifier à la fin de ton do { } while () que tu es bien à la
fin du fichier avec feof() ou qu'il n'y a pas d'erreur avec ferror().
le 22/08/2013 à 20:36, Matt... a écrit dans le message :
J'ai la fonction suivant qui copie un fichier d'un endroit vers un autre. Apparemment il y a un soucis quelque part car la taille de certains fichiers est différente avant et après ???
Je ne vois pas pourquoi tu n'obtiens pas le même résultat.
Par contre : - par définition sizeof(char) == 1 - tu retournes true même si tes lectures/écritures se passent mal (tu vérifies juste que tu as pu ouvrir les fichiers).
Tu devrais vérifier que tes écritures comportes le même nombre de bytes que la lecture.
Tu devrais vérifier à la fin de ton do { } while () que tu es bien à la fin du fichier avec feof() ou qu'il n'y a pas d'erreur avec ferror().