ifstream:: Quelle est la taille de fichier maximale d'un ifstream peut lire

J'ai essayé de lire un 3GB fichier de données à l'aide de ifstream et il me donne le mal de la taille du fichier, alors que quand je lis un fichier de 600 mo, il me donne le résultat correct. En plus des mauvais fichier de taille, je suis aussi incapable de lire le fichier en entier à l'aide de ifstream.

Voici le code que j'ai utilisé

        std::wstring name;
        name.assign(fileName.begin(), fileName.end());
        __stat64 buf;
        if (_wstat64(name.c_str(), &buf) != 0)
            std::cout << -1; //error, could use errno to find out more

        std::cout << " Windows file size : " << buf.st_size << std::endl;;


        std::ifstream fs(fileName.c_str(), std::ifstream::in | std::ifstream::binary);
        fs.seekg(0, std::ios_base::end);

        std::cout << " ifstream  file size: " << fs.tellg() << std::endl;

La sortie de 3 go de fichier a été

 Windows file size : 3147046042
 ifstream  file size: -1147921254

Alors que la sortie pour le fichier de 600 MO a été

 Windows file size : 678761111
 ifstream  file size: 678761111

Juste au cas où, j'ai aussi testé pour 5 GO de fichiers et 300 MO de fichiers,

La sortie pour 5 GO de fichiers a été

Windows file size : 5430386900
 ifstream  file size: 1135419604

La sortie de 300MO fichier a été

Windows file size : 318763632
 ifstream  file size: 318763632

Il me semble qu'il atteint une certaine limite.

Je suis en train de tester le code à l'aide de Visual Studio 2010 sur une Machine Windows qui a beaucoup de mémoire et d'espace disque.

Je suis en train de lire des fichiers volumineux. Ce qui est un bon lecteur de flux à utiliser si ifstream ne peut pas lire des fichiers volumineux?

J'ai remarqué que vous êtes en invoquant _wstat64 directement. Êtes-vous une compilation de 32 bits binaires? Avez-vous essayé 64 bits binaires pour votre ifstream test?
Code 32 bits doit être capable de gérer des fichiers en excès de 2 GO si le système de fichiers n', si non c'est une assez mauvaise bug.
Je suis d'accord, j'étais seulement curieux de savoir si stat() (pas _wstat64()) se sont comportés de la même façon sur un 32bit mise en œuvre, et si ifstream comportés autrement sur un 64 bits de mise en œuvre.
La plate-forme que je suis la compilation est Win32. Je n'ai pas essayé 64 bits binaires.

OriginalL'auteur veda | 2013-05-01

c++ifstream stl

6

Je pense que vous voulez dire:
```
std::cout << " ifstream  file size: " << fs.tellg().seekpos() << std::endl;
```
Au moins qui fonctionne correctement pour un débit de 6 gbits fichier que j'ai autour de la pose. Mais je compile avec Visual Studio 2012. Et même original de votre code fonctionne très bien aussi sur l'environnement.

Donc je pense que c'est un bug dans la prévention des mst bibliothèque sur VS 2010 qui suis fixé dans VS 2012. Si c'est un bug dans la surcharge d'opérateur pour la pos_type ou si cette classe n'est pas 64 bits est inconnue. Je dois installer par rapport à 2010 pour valider, mais c'est probablement le problème.

Selon la Norme, il ne ressemble pas à fpos<char_traits<char>::state_type> (le type retourné par tellg() est censé avoir un public seekpos() membre. Est-ce une mise en œuvre spécifique de l'extension?
Oui, il ne résoudra pas le problème. Maintenant j'obtiens le bon résultat.
Notez que MS obsolète seekpos() avec Visual Studio 15.8, ils ont aussi changé la mise en œuvre retourne toujours 0.

OriginalL'auteur selbie

J'ai modifié votre code légèrement, à quelque chose qui serait de compiler:

#include <fstream>
#include <iostream>
#include <string>
#include <windows.h>

int main() { 

    std::wstring name(L"whatever.txt");

    __stat64 buf;
    if (_wstat64(name.c_str(), &buf) != 0)
        std::cout << -1; //error, could use errno to find out more

    std::cout << " Windows file size : " << buf.st_size << std::endl;;


    std::ifstream fs(name.c_str(), std::ifstream::in | std::ifstream::binary);
    fs.seekg(0, std::ios_base::end);

    std::cout << " ifstream  file size: " << fs.tellg() << std::endl;

    return 0;
}

J'ai essayé cela sur un ~3 Gigaoctets de fichiers. Avec VS 2012 (32 - ou 64-bit), il est produit:

 Windows file size : 3581853696
 ifstream  file size: 3581853696

Avec 32 bits VS 2008 (désolé, de ne pas avoir une copie de VS 2010 est installé pour le moment) j'ai eu:

 Windows file size : 3581853696
 ifstream  file size: -713113600

Donc, il semblerait que les anciennes versions de VS/VC++ utilisé un 32-bit signé nombre de tailles de fichier, de sorte que leur limite pratique pour iostreams était probablement de 2 gigaoctets. Avec VS 2012, qui a apparemment été corrigé.

OriginalL'auteur Jerry Coffin

0

La taille maximale des fichiers sont déterminés par le compilateur et les OS.

Le compilateur a le contrôle sur la taille des variables utilisées pour accéder à des tailles de fichier.

Le système d'exploitation détermine la taille de fichier maximale qu'il peut supporter.

Le langage C++ ne permet pas de limiter la taille du fichier.

Exemple 1:

Le compilateur peut allouer 16 bits pour la position dans le fichier de variable, tandis que le système d'exploitation peut utiliser un pointeur de 32 bits pour la taille de fichier maximale. Dans ce cas, le compilateur est le facteur limitant.

Exemple 2:

Le compilateur peut utiliser 32 bits pour la position dans le fichier de variable, mais le système d'exploitation utilise 24 bits. Dans cet exemple, le système d'exploitation est le facteur limitant.

En résumé, la taille de fichier maximale dépend du compilateur et de l'OS.

Je pense que vous voulez dire de la bibliothèque Standard, pas le compilateur... mais la bibliothèque Standard ne peut être le facteur limitant si vous n'êtes pas à l'aide d'une bibliothèque appropriée pour le système d'exploitation.
La Bibliothèque Standard de déterminer la taille de la filepos variable ou le compilateur? Je sais que la longueur de la size_t est définie par le compilateur.
La bibliothèque Standard. Les types utilisés pour la position dans le fichier ne sont pas spécifiés pour être size_t ou ssize_t, et ne doit généralement pas être, depuis le système de fichiers des limites dépassent largement le pointeur de limites (même sur les systèmes 64 bits, sur lequel les systèmes de fichiers commencent à faire usage de 128 bits longueurs!).

OriginalL'auteur Thomas Matthews

Vous devez vous connecter pour publier un commentaire.