Fonction fwrite

Entête à inclure

#include <stdio.h>  // <cstdio> en C++

Fonction fwrite

size_t fwrite( void * buffer, size_t blocSize, size_t blocCount, FILE * stream );                       // Avant C99
size_t fwrite( void * restrict buffer, size_t blocSize, size_t blocCount, FILE * restrict stream );     // A partir de C99

Cette fonction permet d'écrire un certain nombre d'octets vers le flux spécifié en quatrième paramètre. Les octets à écrire seront stockés dans le buffer passé en premier paramètre. Pour spécifier le nombre d'octets à écrire, il faut jouer sur deux paramètres : le nombre de bloc d'octets à lire ainsi que la taille de chacun des blocs.

Paramètres

• buffer : ce paramètre permet de spécifier le bloc de mémoire dans lequel sont stockés les octets à écrire. Cette taille doit normalement être le produit des paramètres blocSize et blocCount.
• blocSize : spécifie la taille (en nombre d'octets) d'un bloc unitaire à écrire. Pour information, le type size_t renvoie normalement vers unsigned long.
• blocCount : spécifie le nombre de blocs unitaires à écrire.
• stream : représente le flux dans lequels écrire les octets spécifiés. N'oubliez pas que la valeur de ce paramètre à été initialement capturée lors de l'invocation de la fonction fopen.

Valeur de retour

Renvoie le nombre de blocs écris (attention, cette valeur n'est pas exprimée en nombre d'octets, mais bien en nombre de blocs). Si cette valeur est inférieure à la valeur initialement demandée, alors une erreur d'écriture vient de survenir. Dans ce cas, il vous faudra alors consulter la variable errno pour obtenir plus de détails sur la nature exacte de l'erreur constatée.

Codes erreurs pouvant être retournés

EAGAIN : le flux est vérrouillé et il faudra tenter ultérieurement l'écriture.

EBADF : le descripteur de flux (FILE *) passé en paramètre est invalide.

EIO : une erreur d'accès physique au flux vient d'être générée.

Exemple de code

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int main() {

const char * filename = "./test.data";

#define BLOCK_SIZE 24
#define BLOCK_COUNT 10

void writeFile( const char * filename ) {
    char buffer[ BLOCK_SIZE ];
    int returnCode;
    int index;

    FILE * stream = fopen( filename, "w" );
    if ( stream == NULL ) {
        fprintf( stderr, "Cannot open file for writing\n" );
        exit( -1 );
    }

    for( index=0; index<BLOCK_COUNT; index++ ) {
        int value = rand() % 1000;
        sprintf( buffer, "| User %3d | Pass %3d |\n", value, 999-value );
        if ( 1 != fwrite( buffer, BLOCK_SIZE, 1, stream ) ) {
            fprintf( stderr, "Cannot write block in file\n" );
        }
    }

    returnCode = fclose( stream );
    if ( returnCode == EOF ) {
        fprintf( stderr, "Cannot close file\n" );
        exit( -1 );
    }
}

void readFile( const char * filename ) {
    int returnCode;
    int count;

    FILE * stream = fopen( filename, "r" );
    if ( stream == NULL ) {
        fprintf( stderr, "Cannot open file for reading\n" );
        exit( -1 );
    }

    printf( "How many blocks to read: " );
    scanf( "%d", &count );

    {
        char buffer[ BLOCK_SIZE * count + 1];
        if ( count != fread( buffer, BLOCK_SIZE, count, stream ) ) {
            fprintf( stderr, "Cannot read blocks in file\n" );
        }
        buffer[ BLOCK_SIZE * count ] = '\0';
        printf( buffer );
    }

    returnCode = fclose( stream );
    if ( returnCode == EOF ) {
        fprintf( stderr, "Cannot close file\n" );
        exit( -1 );
    }
}


int main() {

    srand( time( NULL ) );

    writeFile( filename );
    readFile( filename );

    return 0;
}

Sujets connexes