C++ de l'écriture et de la lecture double à partir d'un fichier binaire

Je veux faire des disques opérations d'e/S pour un programme qui prend trop de RAM.
J'utilise des matrices de doubles et de penser à les écrire sur le disque comme des octets est le moyen le plus rapide (j'ai besoin de préserver la double précision).

Comment le faire avec la portabilité?

J'ai trouvé ce code ( ici ), mais l'auteur dit que c'est pas portable...

#include <iostream>
#include <fstream>

int main()
{
    using namespace std;

    ofstream ofs( "atest.txt", ios::binary );

    if ( ofs ) {
        double pi = 3.14;

        ofs.write( reinterpret_cast<char*>( &pi ), sizeof pi );
        //Close the file to unlock it
        ofs.close();

        //Use a new object so we don't have to worry
        //about error states in the old object
        ifstream ifs( "atest.txt", ios::binary );
        double read;

        if ( ifs ) {
            ifs.read( reinterpret_cast<char*>( &read ), sizeof read );
            cout << read << '\n';
        }
    }

    return 0;
}
Ce n'est pas portable car sizeof(double) peut être différent entre les plates-formes. Vous aurez besoin de vérifier cela, mais sinon l'exemple de code est ok.
Je serais plus inquiet à propos de l'ordre des octets de double parce que c'est plus enclin à changer (surtout si vous interagissez avec un matériel embarqué).
Vrai, bien que de parler et de penser en termes de "probable" est une mauvaise habitude. Si vous vous souciez vraiment de la portabilité, il n'y a pas de degrés.

OriginalL'auteur Andy | 2011-07-22

  1. 5

    Comment le faire avec la portabilité?

    Il existe différentes définitions/niveaux de la portabilité. Si jamais vous avez à faire est d'écrire sur une seule machine et de le lire sur le même, seule la portabilité qui vous intéresse est de savoir si ce code est bien définie. (C'est).

    Si vous voulez écrire de façon portable à travers plusieurs plates-formes différentes, vous devez écrire chaîne valeurs, plutôt que binaire.

    Cependant, notez que le code que vous avez manque la gestion des erreurs. Il ne vérifie pas si le fichier peut être ouvert et correctement écrit.

    Vous me battre pour la réponse 🙂
    Je suis très désolé. :)
    mon "niveau" de la portabilité est à partir d'ordinateurs personnels (sur windows et linux/unix) pour les clusters. Et je veux écrire des octets parce que j'ai besoin d'un maximum de vitesse et de taille minimale
    Vous avez mal compris. Voulez-vous écrire ces fichiers sur un ordinateur Windows et de les lire sur une machine Unix? Ou voulez-vous écrire et les lire sur la même machine (mais le code devrait fonctionner sur n'importe quelle machine)?
    désolé 🙂 le I/O serait sur la même machine. Serait le coup de pouce de la sérialisation de la bibliothèque être une bonne façon de le faire ?

    OriginalL'auteur sbi

  2. 2

    Je pense que la portabilité problème se produit uniquement lorsque vous écrivez dans un fichier et le lire sur une autre machine. Cependant, puisque vous avez dit que vous voulez lire/écrire dans un fichier en raison de la ram limites, je ne peux que supposer que vous feriez opérations de lecture/écriture sur une seule machine à la fois. Cela devrait fonctionner.

    OriginalL'auteur Luchian Grigore

  3. 1

    Il peut avoir fait allusion à la représentation binaire en général, et pas seulement de sizeof.

    C - la Sérialisation des nombres en virgule flottante (flotteurs, en double)

    La spec ne spécifiez pas de représentation binaire des nombres en virgule flottante. Plus compilateurs suivre IEEE, donc un peu de tests unitaires devraient veiller à ce que le comportement que vous voulez si vous connaissez votre cible plates-formes.

    Mais n'oubliez pas que certaines machines little-endian IEEE et certains utilisent le big-endian IEEE formats - environ Intel et "le reste du monde" (PPC, SPARC, ...).
    Oui, certainement. Je pense que le point est que vous devez écrire des tests pour s'assurer de la validité de chaque plate-forme que vous voulez cibler.

    OriginalL'auteur Tom Kerr

  4. 0

    Habituellement je accéder aux octets de l'union. 

    union Data {
    double val;
    unsigned char str[sizeof(double)];
};

void saveToFile(double *values, int nvalues, const char *filename){
    int i;
    FILE *arq;
    Data num;

    arq=fopen(filename,"w");
    if (arq == NULL) {
        printf("Failed to open file \"%s\"\n", filename);
        exit(0);
    }

    for(i=0; i<nvalues; i++){
        num.val = values[i];
        fwrite (num.str , sizeof(char), sizeof(double), arq);    //ChunkSize
    }

    fclose(arq);
}

void loadFromFile(double *values, int nvalues, const char *filename){
    int i;
    FILE *arq;
    Data num;

    arq=fopen(filename,"r");
    if (arq == NULL) {
        printf("Failed to open file \"%s\"\n", filename);
        exit(0);
    }

    for(i=0; i<nvalues; i++){
        fread(num.str, sizeof(char), sizeof(double), arq);
        values[i] = num.val;
    }

    fclose(arq);
}
    ...qui dans ce cas est juste un mince vernis pour cacher le fait que vous êtes vraiment juste faire un implicite reinterpret_cast. En tant que tel, cela ne fait rien de différent ou de plus de portable, comme demandé par l'OP. Et si vous avez à reinterpret_cast, s'il vous plaît être honnête et de l'écrire explicitement.

    OriginalL'auteur Klaifer Garcia