std:: fseek

Définit l'indicateur de position du fichier pour le flux de fichier stream .

Si le stream est ouvert en mode binaire, la nouvelle position est exactement offset octets mesurés depuis le début du fichier si origin est SEEK_SET , depuis la position courante du fichier si origin est SEEK_CUR , et depuis la fin du fichier si origin est SEEK_END . Les flux binaires ne sont pas tenus de supporter SEEK_END , en particulier si des octets nuls supplémentaires sont produits.

Si le stream est ouvert en mode texte, les seules valeurs prises en charge pour offset sont zéro (qui fonctionne avec n'importe quelle origin ) et une valeur retournée par un appel antérieur à std::ftell sur un flux associé au même fichier (qui fonctionne uniquement avec origin de SEEK_SET ).

Si le stream est orienté large, les restrictions des flux texte et binaire s'appliquent (le résultat de std::ftell est autorisé avec SEEK_SET et un décalage nul est autorisé depuis SEEK_SET et SEEK_CUR , mais pas SEEK_END ).

En plus de modifier l'indicateur de position du fichier, fseek annule les effets de std::ungetc et efface le statut de fin de fichier, le cas échéant.

Si une erreur de lecture ou d'écriture se produit, l'indicateur d'erreur du flux ( std::ferror ) est défini et la position du fichier n'est pas affectée.

Paramètres

Valeur de retour

​ 0 ​ en cas de succès, valeur non nulle sinon.

Notes

Après s'être positionné à une position non finale dans un flux large, le prochain appel à toute fonction de sortie peut rendre le reste du fichier indéfini, par exemple en produisant une séquence multioctet de longueur différente.

POSIX permet de se positionner au-delà de la fin existante du fichier. Si une opération d'écriture est effectuée après ce positionnement, toute lecture de l'espace vide renverra des octets nuls. Lorsque cela est pris en charge par le système de fichiers, cela crée un fichier sparse .

POSIX exige également que fseek effectue d'abord un fflush s'il y a des données non écrites (mais le rétablissement de l'état de décalage est défini par l'implémentation). Les flux de fichiers standard C++ garantissent à la fois le vidage et le rétablissement : std::basic_filebuf::seekoff .

POSIX spécifie que fseek doit renvoyer - 1 en cas d'erreur, et définir errno pour indiquer l'erreur.

Sur Windows, _fseeki64 peut être utilisé pour travailler avec des fichiers de plus de 2 Gio.

Exemple

#include <cassert>
#include <cstdio>
#include <cstdint>
#include <fstream>
#include <vector>
int main()
{
    std::ofstream("dummy.nfo") << "8 bytes\n"; // créer le fichier
    std::FILE* fp = std::fopen("dummy.nfo", "rb");
    assert(fp);
    std::fseek(fp, 0, SEEK_END); // se positionner à la fin
    const std::size_t filesize = std::ftell(fp);
    std::vector<std::uint8_t> buffer(filesize);
    std::fseek(fp, 0, SEEK_SET); // se positionner au début
    std::fread(buffer.data(), sizeof(std::uint8_t), buffer.size(), fp);
    std::fclose(fp);
    std::printf("I've read %zi bytes\n", filesize);
}

I've read 8 bytes

Voir aussi