C

En-tête : <stdio.h>

Fonctions principales :

• FILE *fopen(const char *chemin, const char *mode);
• int fclose(FILE *pointeur_fichier);
• int fputc(int caractere, FILE *pointeur_fichier);
• int fputs(const char *chaine, FILE *pointeur_fichier);
• int fgetc(FILE *pointeur_fichier);
• char *fgets(char *tampon, int taille, FILE *pointeur_fichier);

Exemple :

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

int main() {
    FILE *descripteur;
    descripteur = fopen("./test_c.txt", "w");
    if (descripteur == NULL) {
        perror("Échec de l'ouverture");
        exit(EXIT_FAILURE);
    }
    fprintf(descripteur, "Texte via fprintf\n");
    fputs("Texte via fputs\n", descripteur);
    fclose(descripteur);
    return 0;
}

C++

En-têtes : <fstream>, <iostream>

Fonctions et opérateurs :

• void open(const char *nom_fichier, std::ios::openmode mode);
• void close();
• Opérateur d'insertion (<<) pour l'écriture.
• Opérateur d'extraction (>>) pour la lecture.

Exemple :

#include <fstream>
#include <iostream>
#include <string>
using namespace std;

int main() {
    // Écriture
    ofstream sortie;
    sortie.open("donnees_cpp.txt");
    if (!sortie) {
        cerr << "Erreur d'ouverture en écriture" << endl;
        return 1;
    }
    sortie << "Ligne 1" << endl;
    sortie << "Ligne 2" << endl;
    sortie.close();

    // Lecture
    ifstream entree;
    entree.open("donnees_cpp.txt");
    if (!entree) {
        cerr << "Erreur d'ouverture en lecture" << endl;
        return 1;
    }
    string ligne;
    while (getline(entree, ligne)) {
        cout << "Lu : " << ligne << endl;
    }
    entree.close();
    return 0;
}

API Windows

En-tête : <windows.h>

Fonctions courantes :

• HANDLE CreateFile(LPCSTR nom_fichier, DWORD acces, DWORD partage, LPSECURITY_ATTRIBUTES securite, DWORD creation, DWORD attributs, HANDLE modele);
• BOOL ReadFile(HANDLE fichier, LPVOID tampon, DWORD octets_a_lire, LPDWORD octets_lus, LPOVERLAPPED chevauchement);
• BOOL WriteFile(HANDLE fichier, LPCVOID tampon, DWORD octets_a_ecrire, LPDWORD octets_ecrits, LPOVERLAPPED chevauchement);
• DWORD SetFilePointer(HANDLE fichier, LONG deplacement, PLONG deplacement_haut, DWORD methode);
• BOOL SetEndOfFile(HANDLE fichier);
• BOOL CopyFile(LPCSTR source, LPCSTR destination, BOOL echouer_si_existe);
• BOOL DeleteFile(LPCSTR nom_fichier);
• BOOL MoveFile(LPCSTR ancien, LPCSTR nouveau);
• BOOL CreateDirectory(LPCSTR chemin, LPSECURITY_ATTRIBUTES securite);
• BOOL RemoveDirectory(LPCSTR chemin);
• DWORD GetCurrentDirectory(DWORD taille, LPSTR tampon);
• BOOL SetCurrentDirectory(LPCSTR chemin);

Exemple (copie de fichier) :

#include <windows.h>
#include <stdio.h>
#include <string.h>

int est_repertoire(const char *chemin) {
    WIN32_FIND_DATAA infos;
    HANDLE hRecherche = FindFirstFileA(chemin, &infos);
    if (hRecherche == INVALID_HANDLE_VALUE) return 0;
    int resultat = (infos.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0;
    FindClose(hRecherche);
    return resultat;
}

int main(int argc, char *argv[]) {
    if (argc < 3) {
        printf("Usage : %s source destination\n", argv[0]);
        return 1;
    }
    char source[MAX_PATH], dest[MAX_PATH];
    strncpy(source, argv[1], MAX_PATH);
    strncpy(dest, argv[2], MAX_PATH);

    if (est_repertoire(dest)) {
        strcat(dest, "\\");
        strcat(dest, source);
    }
    if (!CopyFileA(source, dest, FALSE)) {
        perror("Échec de la copie");
        return 1;
    }
    printf("Copie réussie.\n");
    return 0;
}

API Linux

En-têtes : <fcntl.h>, <unistd.h>

Fonctions de base :

• int open(const char *chemin, int drapeaux);
• int open(const char *chemin, int drapeaux, mode_t mode);
• int creat(const char *chemin, mode_t mode);
• ssize_t read(int descripteur, void *tampon, size_t taille);
• ssize_t write(int descripteur, const void *tampon, size_t taille);
• int close(int descripteur);

Exemple (copie de fichier) :

#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>

#define TAILLE_TAMPON 4096

int main(int argc, char *argv[]) {
    if (argc < 3) {
        fprintf(stderr, "Usage : %s source destination\n", argv[0]);
        exit(EXIT_FAILURE);
    }
    int desc_source = open(argv[1], O_RDONLY);
    if (desc_source < 0) {
        perror("Erreur ouverture source");
        exit(EXIT_FAILURE);
    }
    int desc_dest = open(argv[2], O_WRONLY | O_CREAT | O_TRUNC, 0644);
    if (desc_dest < 0) {
        perror("Erreur ouverture destination");
        close(desc_source);
        exit(EXIT_FAILURE);
    }
    char tampon[TAILLE_TAMPON];
    ssize_t octets_lus;
    while ((octets_lus = read(desc_source, tampon, TAILLE_TAMPON)) > 0) {
        if (write(desc_dest, tampon, octets_lus) != octets_lus) {
            perror("Erreur d'écriture");
            close(desc_source);
            close(desc_dest);
            exit(EXIT_FAILURE);
        }
    }
    close(desc_source);
    close(desc_dest);
    return 0;
}