Tronquer un fichier(c - windows)

Soyez le premier à donner votre avis sur cette source.

Snippet vu 11 352 fois - Téléchargée 31 fois

Contenu du snippet

Suite à un problème/demande via le forum: http://www.cppfrance.com/forum.v2.aspx?rm=1&ID=422230

Permet de tronquer un fichier
- modifier sa taille
- retirer X octet(s) dans le fichier(à un endroit quelconque)

cet exemple utilise l'API Windows(directement).

CreateFile(), CreateFileMapping(), MapViewOfFile(), UnmapViewOfFile(),
FlushViewOfFile(), SetFilePointer(), SetEndOfFile(), GetFileSize(),
CloseHandle() et GetLastError().

Il y à aussi une gestion des exceptions en C avec __try/__except pour
les compilateurs les supportants.

Les trois fonctions utilise des entiers 64bits(LONGLONG) pour les fichiers
de plus de 4go, donc, il supporte les fichiers de toutes les tailles.

Le code est un peu `brouillon` mais il fonction et ce n'est qu'un exemple :)

Il n'y à pas de zip car il n'y à qu'un seul et unique petit fichier alors voilà ...

Source / Exemple :


#define WIN32_LEAN_AND_MEAN

#include <windows.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include <stdio.h>
#include <assert.h>

#define MEGA_BIT	(1024 * 1024)	/* 1mb */

/* 64bits */
void MyCopyMemory( void * dst, const void * src, LONGLONG count )
{
	register BYTE * d = (BYTE *) dst;
	register BYTE * s = (BYTE *) src;

	while ( count-- > 0 )

  • d++ = *s++;
} /* modifie la taille d'un fichier */ DWORD SetFileSize( void * pHandle, LONGLONG iSize ) { /* ici on utilise un LARGE_INTEGER pour les fichiers de plus de 4go(plutôt rare mais bon) */ LARGE_INTEGER li; DWORD error = NO_ERROR; assert(pHandle != INVALID_HANDLE_VALUE); assert(pHandle != NULL); li.QuadPart = iSize; /* modifie la position du curseur dans le fichier */ li.LowPart = SetFilePointer( pHandle, li.LowPart, &(li.HighPart), FILE_BEGIN ); if ( (li.LowPart != 0xffffffff) || (NO_ERROR == (error = GetLastError())) ) { /* marque la fin du fichier la ou ce trouve le curseur */ if ( !SetEndOfFile( pHandle ) ) error = GetLastError(); } return error; } /* retire X octet(s) dans un fichier */ DWORD RemoveData( void * pHandle, LONGLONG offset, LONGLONG count ) { /* même chose ici avec le LARGE_INTEGER */ void * map; void * ptr; LARGE_INTEGER fs; DWORD error = NO_ERROR; assert(pHandle != INVALID_HANDLE_VALUE); assert(pHandle != NULL); /* récupère la taille du fichier */ fs.LowPart = GetFileSize( pHandle, &(fs.HighPart) ); if ( (fs.LowPart == 0xffffffff) && (NO_ERROR != (error = GetLastError())) ) return error; /* si `offset` est plus grand que la taille du fichier, on quitte */ if ( offset > fs.QuadPart ) return ERROR_INVALID_PARAMETER; /* ajuste le nombre d'octet à retirer(si besoin) */ if ( (offset + count) > fs.QuadPart ) count = (fs.QuadPart - offset); /* création de la map */ map = CreateFileMapping( pHandle, NULL, PAGE_READWRITE, /* accès en écriture obligatoire */ 0UL, /* on map tout alors 0 partout */ 0UL, NULL ); if ( NULL == map ) return GetLastError(); /* opération final */ ptr = MapViewOfFile( map, FILE_MAP_READ|FILE_MAP_WRITE, /* accès en écriture obligatoire */ 0UL, /* on map tout alors 0 partout */ 0UL, 0UL ); /****************************************************** * `ptr` va contenir l'adresse de la map, qui elle, ce trouve dans `l'address space` du process. Pour manipuler `ptr`, vaut mieux utiliser une autre pointeur. void * newptr = ptr;
  • (BYTE *)newptr++ = 'y';
  • (BYTE *)newptr++ = 'z';
etc ... Si `ptr` est modifié(le pointeur et non son contenue) alors il sera impossible de libérer/fermer la map ... C'est un peu comme une simple allocation mémoire avec malloc()/free() char * ptr = malloc( 50 * sizeof(char) ); ++ptr; free( ptr ); // BOOM!!! *
                                                                                                            • /
if ( NULL != ptr ) { /* prévenir les `access violation` et compagnie */ __try { /* déplace les octets(cast/transtypage obligatoire) */ MyCopyMemory( (BYTE *)ptr + offset, (BYTE *)ptr + (offset + count), count ); } __except ( EXCEPTION_EXECUTE_HANDLER ) { /* Oups! Houston, nous avons un problème ici ... */ error = GetExceptionCode(); } /***************************************************** * UnmapViewOfFile() flush les données lorsqu'elle est appelé mais, d'après MSDN, il le fait lentement/lâchement alors, un FlushViewOfFile() à sa place ici, un peu plus rapide. *
                                                                                                          • /
FlushViewOfFile( ptr, 0UL ); /* 0 car on flush tout */ UnmapViewOfFile( ptr ); /* décharge la map */ } else { error = GetLastError(); } /* ferme la map */ CloseHandle( map ); if ( NO_ERROR == error ) { /* modifie la taille du fichier si aucune erreur */ /* taille du fichier moin les octets retirés */ return SetFileSize( pHandle, (fs.QuadPart - count) ); } return error; } int main( int argc, char * argv[] ) { void * hFile; /* handle du fichier */ char fname[] = ".\\testfile.txt"; /* nom du fichier à ouvrir/modifier */ /* ouverture/création du fichier */ hFile = CreateFile( fname, GENERIC_READ|GENERIC_WRITE, /* accès en écriture obligatoire */ 0UL, /* aucun partage */ NULL, /* aucun attribue de sécurité */ /*OPEN_EXISTING*/CREATE_ALWAYS, /* cré/remplace le fichier */ FILE_ATTRIBUTE_NORMAL|FILE_FLAG_RANDOM_ACCESS, /* attribus/flags */ NULL /* pas de template */ ); /* erreur? */ if ( hFile == INVALID_HANDLE_VALUE ) { printf("CreateFile(): %lu\n", GetLastError()); return 0; } /* modifie la taille du fichier */ printf("SetFileSize(): %lu\n", SetFileSize( hFile, MEGA_BIT )); /* retire les octets de 0+1tier jusqu'a 0+2tier */ /* on retire 1tier du fichier(le centre/millieu du fichier) */ printf("RemoveData(): %lu\n", RemoveData( hFile, (MEGA_BIT / 3), (MEGA_BIT / 3) )); /* ferme le fichier */ CloseHandle( hFile ); putc( '\n', stdout ); return 0; }

Conclusion :


Créé & testé sous Visual Studio 6/Windows 2000 Pro

Cet exemple démontre seulement comment `tronquer`
un fichier sans utiliser d'autres fichiers ou de tampons/buffers
temporaire, etc ... On ouvre le fichier, le modifie et le ferme, tout
simplement!

~(.:: NitRic ::.)~

A voir également

Ajouter un commentaire

Commentaires

NitRic
Messages postés
402
Date d'inscription
mardi 1 mai 2001
Statut
Membre
Dernière intervention
15 août 2011

Okay, utilise ceci alors:

typedef union _LargeInteger
{
struct
{
DWORD LowPart;
LONG HighPart;
};
LONGLONG QuadPart;
}LargeInteger;


ensuite, remplace les `LARGE_INTEGER` par `LargeInteger`




~(.:: NitRic ::.)~
angsthase
Messages postés
72
Date d'inscription
mardi 20 juillet 2004
Statut
Membre
Dernière intervention
11 avril 2005
1
Tout d'abord merci nitric d'avoir fait cette source !!

Ensuite, j'ai eux erreurs lors de la compil :
- union large_integer has no member named low part
- _ _________________________________high ___

???

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.