Le problème de sauvegarde de donnée binaire en C++ et la portabilité

Version imprimable

Voir 40 message(s) de cette discussion en une page

Médinoc, je te remercie, je l'ai déjà corrigé, effectivement cela n'était pas judicieux...
Code:

1 2 3 4 5 6 7 8 9 10 #include <iostream> int main() { unsigned char test[4] = { 0x01, 0x02, 0x03, 0x04 }; std::cout << "Endian: " << std::hex << std::showbase << *(int32_t *) test << std::endl; return 0; }
en revanche, avec std::setw(8), j'ai une erreur 'setw' is not a member of 'std'

18/01/2016, 16h26
ternel

C'est qu'il te manque l'include de <iomanip>. Du coup, j'apprends que std::hex est dans <iostream> (car dans <ios>)

leternel, merci, effectivement le << std::setw(8) marche beaucoup mieux avec le #include <iomanip>Sinon, je constate que les choses ne sont pas si simple que ça :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
#include <iostream>
#include <iomanip>
 
template< typename T>
void convert_LBE( T &obj)
{
    std::cout << "avant conv : " << std::hex << std::showbase << std::setw(8) << obj << std::endl;
    char *obj_char = reinterpret_cast<char *>(&obj);
    char inv_obj_char[sizeof(T)];
 
    for( size_t i = 0; i < sizeof(T); ++i)
    {
        inv_obj_char[i] = obj_char[(sizeof(T) - (i - 1))];
    }
    std::cout << "apres conv : " << std::hex << std::showbase << std::setw(8) << reinterpret_cast<T>(&inv_obj_char) << std::endl;
    obj = (T) inv_obj_char;//reinterpret_cast<T>(&inv_obj_char);
}
 
int main()
{
    unsigned char test[4] = { 0x01, 0x02, 0x03, 0x04 };
    uint32_t test32 = *(int32_t *) test;
 
    std::cout << "Endian: " << std::hex << std::showbase << std::setw(8) << test32 << std::endl;
 
    convert_LBE(test32);
 
    //return *(short *) test;
    std::cout << "Endian: " << std::hex << std::showbase << std::setw(8) << test32 << std::endl;
 
    return 0;
}

18/01/2016, 16h47
Iradrille

Citation:

Envoyé par rnr72

(comment fais-tu le surlignage?)

[c]
18/01/2016, 16h49
rnr72

merci Iradrille.

Sinon, après prise d'informations, je ne suis pas de comprendre l’intérêt, dans mon cas, du std::setw(8)...
18/01/2016, 17h04
Médinoc

C'est vrai qu'avec ta nouvelle valeur de constante d'endianness, il n'y a plus vraiment besoin de padding.
18/01/2016, 17h11
rnr72

Médinoc, je ne comprends pas bien ta remarque...

J'ai mis ma constance de endianness sur 4 octets car j'ai trouvé une info qui parlée également de valeur atomique d'1 ou 2 octets. Après test, il semblerai que sur mon système la question ne se pose pas c'est little endian valeur atomique 1 octet. Mais je me dis que le problème pouvais ce poser et que cela pourrait valoir de coup de le tester aussi.

Mais mon problème actuel est que mon Template ne fonctionne pas...

Ok, j'ai trouvé mon erreur, problème de pointeur et de signe, après correction voici mon code.

Le validez-vous?

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
#include <iostream>
 
template< typename T>
void convert_LBE( T &obj)
{
    if(sizeof(T) != 1 && sizeof(T) <= 8)
    {
        char *obj_char = reinterpret_cast<char *>(&obj);
        char inv_obj_char[sizeof(T)];
 
        for( size_t i = 0; i < sizeof(T); ++i)
        {
            inv_obj_char[i] = obj_char[(sizeof(T) - (i + 1))];
        }
        obj = *reinterpret_cast<T*>(&inv_obj_char);
    }
    else if (sizeof(T) > 8)
    {
        std::cout << "\n\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!" << std::endl;
        std::cout << "!!!    L'objet a convertir contient plus de 8 octets      !!!" << std::endl;
        std::cout << "!!! cette fonction risque de retourner des erreurs en cas !!!" << std::endl;
        std::cout << "!!!  d'utilisation avec une structure ou avec une classe  !!!" << std::endl;
        std::cout << "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n\n" << std::endl;
    }
}
 
struct Test_div_ui
{
    uint64_t value64;
    uint32_t value32;
};
 
int main()
{
    Test_div_ui tdui;
 
    tdui.value32 = 10;
    tdui.value64 = 11;
 
    convert_LBE(tdui);
 
    unsigned char test[4] = { 0x01, 0x02, 0x03, 0x04 };
    uint32_t test32 = *(int32_t *) test;
 
 
    std::cout << "Avant convertion: " << std::hex << std::showbase <<  test32 << std::endl;
 
    convert_LBE(test32);
 
    std::cout << "Apres convertion: " << std::hex << std::showbase << test32 << std::endl;
 
    return 0;
}

18/01/2016, 19h36
dalfab
Le code est ok, mais ensuite que faudra-t-il swapper ou pas?

Pour les problèmes d'endianess et de padding, il faut commencer par bien comprendre le pourquoi.
On ne devrait pas avoir les 2 à la fois.

Exemple : on pose que les données sont écrites en LittleEndian
Code:

1 2 3 4 5 6 7 struct X { unsigned char octet = 0x10; unsigned short hmot = 0x2030; unsigned int mot = 0x40506070; unsigned char octet2 = 0xFF; char message[6]{ "abcde" }; };
Une copie totale de ce POD donnerait (sur un processeur LittleEndian avec padding)
10 ?? 30 20 70 60 50 40 FF 61 62 63 64 65 00 ??
Il est quasi-impossible de relire cette structure sur un processeur BigEndian car où sont les données à swapper, où sont les autres?

Il faut écrire les champs les uns après les autres, pour avoir la séquence binaire :
10 30 20 70 60 50 40 FF 61 62 63 64 65 00
Puis il est possible de les lire les uns après les autres aussi bien en BigEndian qu'en LittleEndian
en connaissant bien à chaque lecture d'un champ :
- S'agit-il d'un nombre entier, d'un flottant ou autre
- Quelle est la taille de l'élément
- => copie, swap2, ou swap4 sur la taille de la donnée suivant les cas
18/01/2016, 20h08
rnr72

dalfab, ne t’inquiètes pas! J'avais bien compris même si je ne connaissais pas le padding ce matin...Je n'ai pas peur d'aller lire de la doc! (chose que j'ai fait immédiatement)

Le problème du padding m'a directement paru évident (tu pourras le constater sur les premiers postes). Le problème de savoir si swap ou pas n'en n'est pas réellement un; je choisirai plus ou moins arbitrairement la façon dont j’écrirai mes fichiers et testerai le système pour savoir si le swap sera nécessaire en sachant qu'il ne le sera pas toujours.

Pour la "serialization" et le problème du padding, je le réglerai ultérieurement.

Je ne présente pas ici mes projets mes uniquement des bouts de code, je créerai un module pour chaque problème.

Celui d’écrire de la donnée binaire n'est pas encore réglé mais cela avance en partie grâce à vous tous et je vous en remercie.

Citation:

copie, swap2, ou swap4 sur la taille de la donnée suivant les cas

Théoriquement, le Template, notamment à savoir si c'est du swap2, 4 ou 8 (enfin si tu parles bien de la taille des variables en octets) est écrit pour ça. Pour la copie (variables de 1 octet) j'ai modifié légèrement le code présent plus haut.

Si vous constatez que je fais des erreurs ou que je n'ai pas compris une notion, nécessitez pas à me le faire remarquer, je suis ouvert aux remarques constructives, en toute courtoisie bien entendu.

Revenons à nos moutons. Le code fournit précédemment était fonctionnel avec l'exemple présent mais ne l'était pas pour d'autres valeurs.

J'ai un peut rebosser la question et vous donne donc ici le code d'une classe de sérialisation et un fichier d'exemple.

Cette classe n'est pas complète. Il serai judicieux d'ajouter par exemple une fonction pour modifier le buffer avec la prise en charge des offsets...

serialize.h

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
#ifndef SERIALIZE_H
#define SERIALIZE_H
 
#include <iostream>
#include <fstream>
#include <vector>
#include <type_traits>
#include <iterator>
#include <algorithm>
 
 
class Serialization
{
public:
    Serialization(const char* nomFichier);
    ~Serialization();
    int save();
    int load();
 
    template< typename T >
    int toBuffer( T &obj)
    {
 
        if (std::is_arithmetic<T>::value && !(std::is_class<T>::value || std::is_union<T>::value || std::is_enum<T>::value))
        {
            char *obj_char = reinterpret_cast<char *>(&obj);
 
            for( size_t i = 0; i < sizeof(T); ++i)
            {
                if (m_little)
                {
                    m_buffer.push_back(obj_char[(sizeof(T) - (i + 1))]);
                }
                else
                {
                    m_buffer.push_back(obj_char[i]);
                }
            }
            return 0;
        }
        else
        {
            std::cout << "\n\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!" << std::endl;
            std::cout <<  "!!!      Vous tentez de \"serializer\" un objet trop        !!!" << std::endl;
            std::cout <<    "!!!       complexe, cela ne peut pas fonctionner!         !!!" << std::endl;
            std::cout <<     "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n\n" << std::endl;
        }
        return -1;
    }
 
    template< typename T >
    int fromBuffer( T &obj )
    {
        if (std::is_arithmetic<T>::value && !(std::is_class<T>::value || std::is_union<T>::value || std::is_enum<T>::value))
        {
            char obj_char[sizeof(T)];
            //char *obj_char = reinterpret_cast<char *>(&obj);
 
            for( size_t i = 0; i < sizeof(T); ++i)
            {
                if (!m_little)
                {
                    obj_char[(sizeof(T) - (i + 1))] = m_buffer.back();
                    m_buffer.pop_back();
                }
                else
                {
                    obj_char[i] = m_buffer.back();
                    m_buffer.pop_back();
                }
            }
 
            obj = *reinterpret_cast<T *>(obj_char);
            return 0;
        }
        else
        {
            std::cout << "\n\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!" << std::endl;
            std::cout <<  "!!!     Vous tentez de \"unserializer\" un objet trop       !!!" << std::endl;
            std::cout <<    "!!!       complexe, cela ne peut pas fonctionner!         !!!" << std::endl;
            std::cout <<     "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n\n" << std::endl;
        }
        return -1;
    }
 
    friend std::ostream& operator<<( std::ostream &flux, Serialization const &seriaz );
 
    template<typename T>
    friend Serialization& operator<<(Serialization &seriaz, T &data)
    {
        if (!std::is_arithmetic<T>::value || std::is_class<T>::value || std::is_union<T>::value || std::is_enum<T>::value)
        {
            std::cout << "\n\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!" << std::endl;
            std::cout <<  "!!!      Vous tentez de \"serializer\" un objet trop        !!!" << std::endl;
            std::cout <<    "!!!       complexe, cela ne peut pas fonctionner!         !!!" << std::endl;
            std::cout <<     "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n\n" << std::endl;
        }
        else
        {
            seriaz.toBuffer(data);
        }
        return seriaz;
    };
 
    template<typename T>
    friend Serialization& operator>>(Serialization &seriaz, T &data)
    {
        if (!std::is_arithmetic<T>::value || std::is_class<T>::value || std::is_union<T>::value || std::is_enum<T>::value)
        {
            std::cout << "\n\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!" << std::endl;
            std::cout <<  "!!!      Vous tentez de \"serializer\" un objet trop        !!!" << std::endl;
            std::cout <<    "!!!       complexe, cela ne peut pas fonctionner!         !!!" << std::endl;
            std::cout <<     "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n\n" << std::endl;
        }
        else
        {
            seriaz.fromBuffer(data);
        }
        return seriaz;
    };
 
    int getSizeBuffer();
 
protected:
    bool testLittleEndian();
 
    const char* m_nomFichier;
    bool m_little;
    std::vector<char> m_buffer;
};
 
#endif // SERIALIZE_H

serialize.cpp

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
#include "serialize.h"
 
 
Serialization::Serialization(const char* nomFichier): m_nomFichier(nomFichier), m_little(testLittleEndian())
{
 
}
 
Serialization::~Serialization()
{
 
}
 
std::ostream& operator<<( std::ostream &flux, Serialization const& seriaz)
{
    std::copy(seriaz.m_buffer.begin(), seriaz.m_buffer.end(), std::ostreambuf_iterator<char>(flux));
    return flux;
}
 
int Serialization::getSizeBuffer()
{
    return m_buffer.size();
}
 
bool Serialization::testLittleEndian()
{
    unsigned char test[2] = { 0x1, 0x0};
 
    return *(short *) test;
}
 
int Serialization::save()
{
    std::ofstream file (m_nomFichier, std::ios::in|std::ios::binary|std::ios::trunc);
 
    std::copy(m_buffer.begin(), m_buffer.end(), std::ostreambuf_iterator<char>(file));
 
    file.close();
 
    return 0;
}
 
int Serialization::load()
{
    std::ifstream file (m_nomFichier, std::ios::out|std::ios::binary);
 
    if(!file.is_open())
    {
        std::cout << "Erreur à l'ouverture du fichier " << m_nomFichier << std::endl;
        return 1;
    }
 
    if(!m_buffer.empty()) m_buffer.clear();
 
    std::copy(std::istream_iterator<char>(file), std::istream_iterator<char>(), std::back_inserter(m_buffer));
 
    file.close();
 
    return 0;
}

test.cpp

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
#include "serialize.h"
 
struct Test_div_ui
{
    uint64_t value64;
    uint32_t value32;
};
 
int main()
{
    Test_div_ui tdui;
    tdui.value32 = 10;
    tdui.value64 = 11;
 
    unsigned char test[4] = { 0x03, 0x04, 0x05, 0x06 };
    uint32_t test32 = *(uint32_t *) test;
    int16_t i = 0x0001;
    char c1 = 3;
    char c2 = 4;
    char c3 = 5;
    char c4 = 6;
    double d = 555.777;
 
    Serialization fichierTest("test.dat");
 
    fichierTest << tdui;
    std::cout << "Contenu buffer :" << fichierTest << ": taille en octet : " << fichierTest.getSizeBuffer() << std::endl;
    fichierTest << c1;
    std::cout << "Contenu buffer :" << fichierTest << ": taille en octet : " << fichierTest.getSizeBuffer() << " : data : " << c1 << std::endl;
    fichierTest << c2;
    std::cout << "Contenu buffer :" << fichierTest << ": taille en octet : " << fichierTest.getSizeBuffer() << " : data : " << c2 << std::endl;
    fichierTest << c3;
    std::cout << "Contenu buffer :" << fichierTest << ": taille en octet : " << fichierTest.getSizeBuffer() << " : data : " << c3 << std::endl;
    fichierTest << c4;
    std::cout << "Contenu buffer :" << fichierTest << ": taille en octet : " << fichierTest.getSizeBuffer() << " : data : " << c4 << std::endl;
    fichierTest << test32;
    std::cout << "Contenu buffer :" << fichierTest << ": taille en octet : " << fichierTest.getSizeBuffer() << " : data : " << test32 << std::endl;
    fichierTest << i;
    std::cout << "Contenu buffer :" << fichierTest << ": taille en octet : " << fichierTest.getSizeBuffer() << " : data : " << i << std::endl;
    fichierTest << d;
    std::cout << "Contenu buffer :" << fichierTest << ": taille en octet : " << fichierTest.getSizeBuffer() << " : data : " << d << std::endl;
 
    fichierTest.save();
    fichierTest.load();
 
    fichierTest >> d;
    std::cout << "Contenu buffer :" << fichierTest << ": taille en octet : " << fichierTest.getSizeBuffer() << " : data : "  << d << std::endl;
    fichierTest >> i;
    std::cout << "Contenu buffer :" << fichierTest << ": taille en octet : " << fichierTest.getSizeBuffer() << " : data : "  << i << std::endl;
    fichierTest >> test32;
    std::cout << "Contenu buffer :" << fichierTest << ": taille en octet : " << fichierTest.getSizeBuffer() << " : data : "  << test32 << std::endl;
    fichierTest >> c4;
    std::cout << "Contenu buffer :" << fichierTest << ": taille en octet : " << fichierTest.getSizeBuffer() << " : data : "  << c4 << std::endl;
    fichierTest >> c3;
    std::cout << "Contenu buffer :" << fichierTest << ": taille en octet : " << fichierTest.getSizeBuffer() << " : data : "  << c3 << std::endl;
    fichierTest >> c2;
    std::cout << "Contenu buffer :" << fichierTest << ": taille en octet : " << fichierTest.getSizeBuffer() << " : data : " << c2 << std::endl;
    fichierTest >> c1;
    std::cout << "Contenu buffer :" << fichierTest << ": taille en octet : " << fichierTest.getSizeBuffer() << " : data : " << c1 << std::endl;
 
 
    return 0;
}

Si vous voyez de erreurs ou si vous avez des commentaires ou suggestions, n'hésitez pas à m'en faire part.

21/01/2016, 13h30
Bousk

C'est un problème récurrent en réseau, et on a les fonctions ntohs, ntohl, htons, htonl pour gérer ça.
21/01/2016, 13h51
rnr72

Bousk, j'ai bien précisé que dans la mesure du possible, je ne souhaitais pas utiliser de librairie tierce (car je n'ai rien trouvé dans les références cpp) sinon j'aurai tout fais avec Boost...
Même si cela peut paraitre une perte de temps, je considère que cela a au moins une valeur pédagogique.
Mais ta remarque reste intéressante car il est vrai que c'est un problème également récurent en réseaux lors de la construction de paquets.
21/01/2016, 14h10
rnr72

dragonjoker59, désolé, mais quand je cherche "cpp references ntohs", je ne trouve rien de probant.

De plus, après recherches complémentaires, ces fonctions ne sont que pour des uint16_t ou uint32_t (je peux me tromper, je vous fais juste part de mes découvertes après des recherches rapides).

Et ma classe fait un peut plus que de la conversion d'ordre d'octets...
21/01/2016, 14h11
Médinoc

De plus, htonl() et compagnie ne connaissent que deux ordres d'octets: big-endian et "hôte". Elles n'ont rien qui soit garanti manipuler des données little-endian, et sur une machine big-endian, elles ne font rien du tout!

PS: Ces fonctions font partie du standard POSIX et peut-être aussi de la spécification des sockets Berkeley, mais ne font pas partie du standard C.
21/01/2016, 15h16
Bousk

Citation:

Envoyé par Médinoc

De plus, htonl() et compagnie ne connaissent que deux ordres d'octets: big-endian et "hôte". Elles n'ont rien qui soit garanti manipuler des données little-endian, et sur une machine big-endian, elles ne font rien du tout![/SIZE]

Parce que c'est précisément leur but et la seule chose utile à savoir en pratique. :weird:
Ce qui importe c'est
- de sérialiser les données locales vers un endianess connu (network/big-endian parce que c'est celui qui a été choisi, arbitrairement, pour les échanges réseau)
- faire l'opération inverse
21/01/2016, 16h48
Médinoc

D'où le point que je voulais soulever: Ces fonctions sont inappropriées pour toute autre chose, comme un format de sauvegarde où l'endianness est variable (et si elle est fixe, pas besoin de l'indiquer dans la sauvegarde).

D'un autre côté, je ne dis pas qu'un format à endianness variable est une mauvaise idée: Bien fait, c'est le plus performant pour communiquer entre deux machines ayant la même endianness, quelle qu'elle soit.
21/01/2016, 17h03
rnr72

Re!

J'ai découvert un nouveau problème. Je ne doute pas qu'il vient de mon code mais il est plutôt étrange, j'ai un problème avec le caractère 0x20. Il est écrit dans le fichier mais n'est pas intégré au buffer à la lecture du fichier...
21/01/2016, 17h14
Médinoc

istream_iterator ne fait-il pas, en pratique, l'équivalent d'un >>?

Si oui, tu vas devoir utiliser autre chose à la place (du genre istream::read()).
21/01/2016, 17h23
rnr72

J'ai résolu le problème avec une bête boucle while file.get(c)

Voir 40 message(s) de cette discussion en une page