La fonction tellg () donne une mauvaise taille de fichier?

J'ai fait un exemple de projet de lecture d'un fichier dans un buffer.
Lorsque j'utilise le tellg (), fonction qu'il me donne une valeur plus grande que la
la fonction de lecture est en fait de lire le fichier. Je pense qu'il y a un bug.

voici mon code:

EDIT:

    void read_file (const char* name, int *size , char*& buffer)
    {
        ifstream file;

        file.open(name,ios::in|ios::binary);
        *size = 0;
        if (file.is_open())
        {
            //get length of file
            file.seekg(0,std::ios_base::end);
            int length = *size = file.tellg();
            file.seekg(0,std::ios_base::beg);

            //allocate buffer in size of file
            buffer = new char[length];

            //read
            file.read(buffer,length);
                    cout << file.gcount() << endl;
         }
         file.close();
    }

principal:

  void main()
  {
    int size = 0;
    char* buffer = NULL;
    read_file("File.txt",&size,buffer);

    for (int i = 0; i < size; i++)
        cout << buffer[i];
    cout << endl; 
  }

source d'informationauteur Elior

  1. 31

    tellg ne prend pas en compte de la taille du fichier, ni le décalage
    depuis le début, en octets. Il fait état d'une valeur de jeton qui peut
    plus tard être utilisé pour demander à la même place, et rien de plus.
    (Il n'est même pas garanti que vous pouvez convertir le type à un
    type intégral.)

    Au moins selon la spécification du langage: dans la pratique,
    sur les systèmes Unix, la valeur retournée sera le décalage en octets
    à partir du début du fichier, et sous Windows, il sera
    le décalage à partir du début du fichier pour les dossiers ouverts
    le mode binaire    . Pour Windows (et la plupart des systèmes non-Unix), dans le texte
    mode, il n'y a aucun lien direct et immédiat de la cartographie entre ce
    tellg retourne et le nombre d'octets que vous devez lire pour se rendre à
    de cette position. Sous Windows, tout ce que vous pouvez vraiment compter sur est
    la valeur sera pas moins que le nombre d'octets que vous avez
    à lire (et dans la plupart des cas réels, ne sera pas trop grand,
    bien qu'il peut être jusqu'à deux fois plus).

    Si il est important de savoir exactement combien d'octets que vous pouvez lire,
    le seul moyen fiable de le faire est par la lecture. Vous devez être
    en mesure de le faire avec quelque chose comme:

    file.ignore( std::numeric_limits<std::streamsize>::max() );
std::streamsize length = file.gcount();
file.clear();   // Since ignore will have set eof.
file.seekg( 0, std::ios_base::beg );

    Enfin, deux autres remarques concernant votre code:

    Tout d'abord, la ligne:

    *buffer = new char[length];

    ne devrait pas compiler: vous avez déclaré que buffer être un char*
    donc *buffer a type char, et n'est pas un pointeur. Compte tenu de ce que
    vous semblez être en train de faire, vous voulez probablement déclarer buffer comme
    un char**. Mais une bien meilleure solution serait de le déclarer
    comme un std::vector<char>& ou un std::string&. (De cette façon, vous
    ne pas avoir de retour de la taille en tant que bien, et vous n'aurez pas de fuite de mémoire
    si il y a une exception).

    Deuxième, la condition de la boucle à la fin est mauvaise. Si vous avez vraiment
    voulez lire les caractères un à un,

    while ( file.get( buffer[i] ) ) {
    ++ i;
}

    devrait faire l'affaire. Une meilleure solution serait probablement d'
    lire des blocs de données:

    while ( file.read( buffer + i, N ) || file.gcount() != 0 ) {
    i += file.gcount();
}

    ou encore:

    file.read( buffer, size );
size = file.gcount();

    EDIT: je viens de remarquer une troisième erreur: si vous ne parvenez pas à ouvrir le
    fichier, vous ne dites pas à l'appelant. À tout le moins, vous devriez
    définir la size à 0 (mais une sorte d'erreur plus précis
    la manipulation est sans doute mieux).

  2. 1
    fseek(fptr, 0L, SEEK_END);
filesz = ftell(fptr);

    fera le fichier si le fichier est ouvert par fopen

    à l'aide de ifstream,

    in.seekg(0,ifstream::end);
dilesz = in.tellg();

    ferait similaire

  3. 0
    void read_file (int *size, char* name,char* buffer)
*buffer = new char[length];

    Ces lignes ne regardent pas comme un bug: vous créez un tableau de char et d'économiser sur le tampon[0] char. Puis vous lisez un fichier vers un tampon, qui est toujours initialisée.

    Vous avez besoin pour passer buffer par pointeur:

    void read_file (int *size, char* name,char** buffer)
*buffer = new char[length];

    Ou par référence, qui est le c++ et est moins sujette aux erreurs:

    void read_file (int *size, char* name,char*& buffer)
buffer = new char[length];
...