Re: encoding a float

From:

Greg Herlihy <greghe@pacbell.net>

Newsgroups:

comp.lang.c++.moderated

Date:

Tue, 27 Mar 2007 16:37:44 CST

Message-ID:

<C22EB7EB.5A41%greghe@pacbell.net>

On 3/27/07 11:59 AM, in article
1175013683.517285.310120@o5g2000hsb.googlegroups.com, "hurcan solter"
<hsolter@gmail.com> wrote:

On Mar 27, 7:43 pm, Ulrich Eckhardt <eckha...@satorlaser.com> wrote:

It does work:

  // serialize
  vec.resize(sizeof deneme);
  memcpy( &vec.front(), &deneme, sizeof deneme);

  // deserialize
  assert(vec.size() >= sizeof deneme);
  memcpy( &deneme2, &vec.front(), sizeof deneme);

HOWEVER: you still have a big problem there and that is that the layout

floating-point values in memory is not portable between different
architectures. Therefore, I'd suggest you use a text-based format which
makes it much easier to transfer the data between different machines.

thanks for the answer and it works. thing is i am not at liberty to
change the format
of layout. it must be BigEndian 32-bit IEEE normalized single-
precision format
(this is what i understand from memory layout)
which happens to be same on my platform,except the endiannes which i
deal with
before serializing it. so as long as the other side know how to
convert it
back to its native data type there should'nt be any problems right?

Well, the "other side" upon receiving one of these serialized floats, has to
"know" whether the stored value has a big- or little-endian format. Ideally,
the receiver should have to make as few assumptions as possible about the
data it receives, so - as long as storage is not extremely constrained - a
more flexible solution would be to encode the float's hexadecimal
representation as a string stored in a fixed-size character array. The bytes
of this character array are then sent to the receiver.

Furthermore, since this is a C++ program, serializing and de-serializing the
float could be encapsulated as methods of a POD-struct - so that the
implementation details would not obscure the operation being performed:

    #include <vector>
    #include <cstdlib>
    #include <string>

    using std::vector;
    using std::snprintf;
    using std::scanf;
    using std::strtof;

    // Float is a POD-struct suitable for storage or transport

    struct Float
    {
        Float( float f = 0.0f)
        {
            snprintf(rep, sizeof(rep), "%.6A", double(f));
        }

        operator float() const
        {
            return strtof( rep, NULL);
        }

        Float &operator=( const Float& rhs)
        {
            std::memcpy( rep, rhs.rep, sizeof(rep));
            return *this;
        }

    private:
        char rep[16];
    };

    int main()
    {
        float deneme = 3.1415926535f;
        float deneme2 = 0.0f;

        vector<Float> vec;

        // each float is serialized into a 16-byte char array

        vec.push_back( deneme );
        vec.push_back( deneme2 );

        int pos = 0;

        deneme = vec[pos++];
        deneme2 = vec[pos++];
    }

Note that this program still needs to be filled in a bit (specifically,
extracting and constructing a Float from the 16 byte character array has
been omitted due to space constraints. :-)

Greg

--
      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]