Very Computer

Any suggestion? Please help!

- Jing-Hou Li

Simply use a cast. For example, if you wanted to write a float into a char
array:

   char buffer [BUFSIZE];
   float f;
   int i;
   char *c;

   f = get_float_val ();        /* initialise f */
   c = (char *)f;               /* set c to point to f */

   /* copy f into buffer */
   for (i = 0; i < sizeof (float); ++i)
      buffer [i] = *(c++);

Simply reverse the last line to unpack the buffer back into the
float:

      *(c++) = buffer [i];

The method is the same for an array of floats, or any other data
type (simply adjust the "i < sizeof ..." to the correct size).

--

 Michael Davis   \     WWW:     http://www.he.tdl.com/~jubjub/

 Software engineer solicits new C/C++/UNIX contracts ... see my web page
                PGP public key available via finger, WWW, or key servers

Quote:Jinghou Li <jli> writes:
>I am writing a program that needs to send arbitrary type of data via BSD
>socket.
>Right now, I am using a char array to buffer those data. In my implementation
>one thing is guaranteed: both the sending and receiving ends know what type of
>data it's supposed to write/read. So, I am worrying about how to convert
>any type of data into char string and the reverse. The solution should be
>portable as all kinds fo UNIXs are supposed to run this program.
>Any suggestion? Please help!

However, if you want to run the program on different machines (such that they
represent floats differently), you need to use something like XDR, which
converts data into a common format before sending, and converts it back when
receiving.

D. Yue

struct template {
    int something;
    long youpick;
    struct gluttonforpunishment {
        char string[104];
        int whatever;
    }

Quote:} *tptr;

Jeff S.*son

Jeff S.*son

1) Do it with sprintf()/sscanf() if the data aren't too large

2)Use XDR and the associated C routine generators to
generate automatic conversion routines from native data to machine-neutral
format and back. Warning: XDR does not exist on all machines.
--

  Ingenieur logiciel - Developpement d'applications AIX
  Software engineer - AIX Application Development

c = (char *) &f
             =

If you have a limited set of data types you wish to transfer, the easiest way
to do so is to transfer data as character arrays using sprintf()/sscanf() to
format/extract. For transfer of various complex types, I would look at ASN.1
or XDR

-ascs

Portable to a wider range of machines is:

struct template {
    int something:16;
    int pad:16;
    int youpick:32;
    struct gluttonforpunishment {
        char string[104];
        int whatever:16;
    };

Quote:} *tptr;

struct template {
    int youpick:32;
    int something:16;
    struct gluttonforpunishment {
        char string[104];
        int whatever:16;
    };

Quote:} *tptr;

It is safer to disassemble / assemble integers to/from single chars.
This way, you can broaden the portability to all systems that have >= 8 bit
chars, BSD style sockets and transmit 8 bit/char on sockets.

( It may be argued that sockets no longer have
  BSD style if you transfer anything but 8 bits/char )

Sort of a tradeoff between the degree of unportability and unmaintability :-)

If you have some CPU cycles to burn, you can write your own portable XDR
library (to overcome the problem that not all machines have XDR) and use
that.

        Joern Rennecke