write a binary file?

Discussion in 'C Programming' started by cylin, Apr 19, 2004.

  1. cylin

    cylin Guest

    Dear all,

    I open a binary file and want to write 0x00040700 to this file.
    how can I set write buffer?
    ---------------------------------------------------
    typedef unsigned char UCHAR;
    int iFD=open(szFileName,O_CREAT|O_BINARY|O_TRUNC|O_WRONLY,S_IREAD|S_IWRITE);
    UCHAR buffer[5]; //???????????
    write(iFD,buffer,5);
    ---------------------------------------------------

    Thanks.

    Regards,
    cylin.
     
    cylin, Apr 19, 2004
    #1
    1. Advertising

  2. cylin

    Richard Bos Guest

    "cylin" <> wrote:

    > I open a binary file and want to write 0x00040700 to this file.
    > how can I set write buffer?


    Not like this, in ISO C. What you've got is system-specific, either
    POSIX or not-quite-POSIX-M$.

    > typedef unsigned char UCHAR;


    Yeugh.

    > int iFD=open(szFileName,O_CREAT|O_BINARY|O_TRUNC|O_WRONLY,S_IREAD|S_IWRITE);


    Hungarian notation. Double yeugh. HN used to declare what everybody
    reading your code, including the compiler, already knows: the types of
    your identifiers. Triple yeugh, and go to the self-confidence shop and
    buy some.

    > UCHAR buffer[5]; //???????????


    Mixing declarations and executable statements is legal in C99 and C++,
    but not in C89. Beware the snark.

    > write(iFD,buffer,5);


    No idea how to solve this using your low-level, unlikely-to-port
    functions. In _real_ C, you'd do something like this:

    #include <stdio.h>

    unsigned char buf[5];
    FILE *outfile;

    if (!(outfile=fopen(filename, "wb")) {
    puts("This is the place where you'd handle a file open error.");
    } else {
    if (fwrite(buf, sizeof *buf, sizeof buf/sizeof *buf, outfile) !=
    sizeof buf/sizeof *buf) {
    puts("Handle a write error here.");
    }
    /* Or, since you know that buf is an unsigned char array and
    therefore sizeof *buf must be 1:
    fwrite(buffer, 1, sizeof buf, outfile);
    */
    fclose(outfile);
    /* For critical applications, you should even check the return value
    of fclose(), but I rarely do this. */
    }

    Issa dat si'ple.

    Richard
     
    Richard Bos, Apr 19, 2004
    #2
    1. Advertising

  3. "cylin" <> wrote:
    >
    >I open a binary file and want to write 0x00040700 to this file.
    >how can I set write buffer?


    Do you want to
    [1] write bytes in exactly the order you gave above (portable
    result), or
    [2] write an unsigned long value to the file (non-portable
    result)?

    >---------------------------------------------------
    >typedef unsigned char UCHAR;
    >int iFD=open(szFileName,O_CREAT|O_BINARY|O_TRUNC|O_WRONLY,S_IREAD|S_IWRITE);
    >UCHAR buffer[5]; //???????????
    >write(iFD,buffer,5);
    >---------------------------------------------------


    Neither open nor write are standard C functions.
    What you want is something like:

    #include <stdio.h>
    #include <stdlib.h>

    int main( void )
    {
    unsigned char buf[] = { 0x00, 0x04, 0x07, 0x00 };
    unsigned long ul = 0x00040700UL;
    FILE *fp;

    if ( ( fp = fopen( "foo", "wb" ) ) != NULL )
    {
    fwrite( buf, sizeof buf, 1, fp ); /* [1] */
    fwrite( &ul, sizeof ul, 1, fp ); /* [2] */
    fclose( fp );
    return EXIT_SUCCESS;
    }
    return EXIT_FAILURE;
    }

    HTH
    Regards
    --
    Irrwahn Grausewitz ()
    welcome to clc: http://www.ungerhu.com/jxh/clc.welcome.txt
    clc faq-list : http://www.faqs.org/faqs/C-faq/faq/
    clc OT guide : http://benpfaff.org/writings/clc/off-topic.html
     
    Irrwahn Grausewitz, Apr 19, 2004
    #3
  4. "cylin" <> writes:

    > Dear all,
    >
    > I open a binary file and want to write 0x00040700 to this file.
    > how can I set write buffer?


    Use shifts and mask operations (bitwise AND) to extract the individual
    bytes. The details depend on the byte order in which you want to write
    to the file.

    > ---------------------------------------------------
    > typedef unsigned char UCHAR;
    > int iFD=open(szFileName,O_CREAT|O_BINARY|O_TRUNC|O_WRONLY,S_IREAD|S_IWRITE);


    No such function in standard C. Use `fopen'.

    > UCHAR buffer[5]; //???????????
    > write(iFD,buffer,5);


    No such function in standard C. Use `fwrite'.

    > ---------------------------------------------------


    This program should give you same hints:


    #include <stdlib.h>
    #include <stdio.h>

    int main (void)
    {
    const unsigned long value = 0x00040700;
    unsigned char buffer [4];
    FILE *f;

    /* This as known as "big-endian" byte order. */
    buffer [0] = value >> 24;
    buffer [1] = (value >> 16) & 0xFF;
    buffer [2] = (value >> 8) & 0xFF;
    buffer [3] = value & 0xFF;

    f = fopen ("testfile", "wb");
    if (f != NULL)
    {
    if (fwrite (buffer, sizeof *buffer, sizeof buffer, f) < sizeof buffer
    || fclose (f) == EOF)
    {
    fputs ("Error writing to testfile.\n", stderr);
    return EXIT_FAILURE;
    }
    }
    else
    {
    fputs ("Cannot open testfile for writing.\n", stderr);
    return EXIT_FAILURE;
    }

    return 0;
    }


    Martin


    --
    ,--. Martin Dickopp, Dresden, Germany ,= ,-_-. =.
    / ,- ) http://www.zero-based.org/ ((_/)o o(\_))
    \ `-' `-'(. .)`-'
    `-. Debian, a variant of the GNU operating system. \_/
     
    Martin Dickopp, Apr 19, 2004
    #4
  5. (Richard Bos) writes:

    > if (fwrite(buf, sizeof *buf, sizeof buf/sizeof *buf, outfile) !=
    > sizeof buf/sizeof *buf) {
    > puts("Handle a write error here.");
    > }
    > fclose(outfile);
    > /* For critical applications, you should even check the return value
    > of fclose(), but I rarely do this. */


    Why do you check the return value of `fwrite' then? Most operating
    systems don't write immediately to the underlying device when `fwrite'
    is called, but have some buffering mechanism. Therefore, an error is
    far more likely to show up in `fclose' than in `fwrite' on such systems.

    Martin


    --
    ,--. Martin Dickopp, Dresden, Germany ,= ,-_-. =.
    / ,- ) http://www.zero-based.org/ ((_/)o o(\_))
    \ `-' `-'(. .)`-'
    `-. Debian, a variant of the GNU operating system. \_/
     
    Martin Dickopp, Apr 19, 2004
    #5
  6. Martin Dickopp <> writes:

    > if (fwrite (buffer, sizeof *buffer, sizeof buffer, f) < sizeof buffer


    That's inconsistent. Make that:

    if (fwrite (buffer, 1, sizeof buffer, f) < sizeof buffer

    Martin


    --
    ,--. Martin Dickopp, Dresden, Germany ,= ,-_-. =.
    / ,- ) http://www.zero-based.org/ ((_/)o o(\_))
    \ `-' `-'(. .)`-'
    `-. Debian, a variant of the GNU operating system. \_/
     
    Martin Dickopp, Apr 19, 2004
    #6
  7. cylin

    cylin Guest

    Re: write a binary file? (Can't low-level I/O functions do this case?)

    Great. Thank all.

    I use low-level I/O functions because I want to the speed faster than
    stardard I/O functions.
    Can't low-level I/O functions do this case?

    Regards,
    cylin.
     
    cylin, Apr 19, 2004
    #7
  8. Re: write a binary file? (Can't low-level I/O functions do thiscase?)

    "cylin" <> writes:

    > I use low-level I/O functions because I want to the speed faster than
    > stardard I/O functions.
    > Can't low-level I/O functions do this case?


    They can, but they're off-topic in comp.lang.c, which is only about
    standard C.

    <OT>
    They are also harder to use correctly. Note, e.g., that it is not
    necessarily an indication of error if the POSIX function `write' writes
    less bytes than requested.
    </OT>

    Martin


    --
    ,--. Martin Dickopp, Dresden, Germany ,= ,-_-. =.
    / ,- ) http://www.zero-based.org/ ((_/)o o(\_))
    \ `-' `-'(. .)`-'
    `-. Debian, a variant of the GNU operating system. \_/
     
    Martin Dickopp, Apr 19, 2004
    #8
  9. Re: write a binary file? (Can't low-level I/O functions do this case?)

    cylin <> scribbled the following:
    > Great. Thank all.


    > I use low-level I/O functions because I want to the speed faster than
    > stardard I/O functions.
    > Can't low-level I/O functions do this case?


    First of all, your "low-level I/O functions" might not even be available
    on all platforms. Second of all, there is no guarantee they will be any
    faster than standard I/O functions. They could even be slower.

    --
    /-- Joona Palaste () ------------- Finland --------\
    \-- http://www.helsinki.fi/~palaste --------------------- rules! --------/
    "C++ looks like line noise."
    - Fred L. Baube III
     
    Joona I Palaste, Apr 19, 2004
    #9
  10. cylin

    CBFalconer Guest

    Martin Dickopp wrote:
    > "cylin" <> writes:
    >
    >> I open a binary file and want to write 0x00040700 to this file.
    >> how can I set write buffer?

    >
    > Use shifts and mask operations (bitwise AND) to extract the
    > individual bytes. The details depend on the byte order in which
    > you want to write to the file.
    >

    .... snip ...
    >
    > This program should give you same hints:
    >
    > #include <stdlib.h>
    > #include <stdio.h>
    >
    > int main (void)
    > {
    > const unsigned long value = 0x00040700;
    > unsigned char buffer [4];
    > FILE *f;
    >
    > /* This as known as "big-endian" byte order. */
    > buffer [0] = value >> 24;
    > buffer [1] = (value >> 16) & 0xFF;
    > buffer [2] = (value >> 8) & 0xFF;
    > buffer [3] = value & 0xFF;
    >
    > f = fopen ("testfile", "wb");
    > if (f != NULL)
    > {
    > if (fwrite (buffer, sizeof *buffer, sizeof buffer, f) < sizeof buffer
    > || fclose (f) == EOF)
    > {
    > fputs ("Error writing to testfile.\n", stderr);
    > return EXIT_FAILURE;
    > }
    > }
    > else
    > {
    > fputs ("Cannot open testfile for writing.\n", stderr);
    > return EXIT_FAILURE;
    > }
    >
    > return 0;
    > }


    There is nothing wrong with your code above, and it illustrates
    most things admirably, I suggest that the use of embedded tests
    will facilitate a clearer order of things. This is a style
    question, not a flame, and just a suggestion. My version follows:

    #include <stdlib.h>
    #include <stdio.h>

    int main (void)
    {
    const unsigned long value = 0x00040700;
    unsigned char buffer [4];
    FILE *f;

    /* This as known as "big-endian" byte order. */
    buffer [0] = value >> 24;
    buffer [1] = (value >> 16) & 0xFF;
    buffer [2] = (value >> 8) & 0xFF;
    buffer [3] = value & 0xFF;

    if (!(f = fopen("testfile", "wb"))) {
    fputs("Cannot open testfile for writing.\n", stderr);
    }
    else if ((fwrite(buffer, sizeof *buffer, sizeof buffer, f)
    < sizeof buffer)
    || (EOF == fclose(f))) {
    fputs("Error writing to testfile.\n", stderr);
    }
    else {
    return 0;
    }
    return EXIT_FAILURE;
    }

    although the neophyte is still going to have trouble comprehending
    the combined fwrite/fclose failure test. I have also added the
    odd extraneous parentheses to make the meanings explicit.

    This now follows the pattern "if phasefails exit else nextphase".

    --
    Some useful references:
    <http://www.ungerhu.com/jxh/clc.welcome.txt>
    <http://www.eskimo.com/~scs/C-faq/top.html>
    <http://benpfaff.org/writings/clc/off-topic.html>
    <http://anubis.dkuug.dk/jtc1/sc22/wg14/www/docs/n869/> (C99)
     
    CBFalconer, Apr 19, 2004
    #10
  11. cylin

    Dan Pop Guest

    In <> (Richard Bos) writes:

    > fclose(outfile);
    > /* For critical applications, you should even check the return value
    > of fclose(), but I rarely do this. */


    Bad idea: most of the things that can go wrong (after fopen succeeded)
    happen at fclose time.

    To optimise the error checking, when I generate an output file in a
    compact succession of operations, I only check fclose and a fflush call
    immediately preceding it (which is probably redundant).

    OTOH, long running programs that generate output constantly (e.g. one
    printf call per main loop iteration) should check each output call,
    even if it's on stdout (that gets redirected to a file when the program
    is run in non-interactive mode). No point in continuing the execution
    if the program can no longer generate output.

    Dan
    --
    Dan Pop
    DESY Zeuthen, RZ group
    Email:
     
    Dan Pop, Apr 19, 2004
    #11
  12. cylin

    Dan Pop Guest

    Re: write a binary file? (Can't low-level I/O functions do this case?)

    In <c600ft$6bclo$-berlin.de> "cylin" <> writes:

    >I use low-level I/O functions because I want to the speed faster than
    >stardard I/O functions.


    Where did you get this silly idea from? The low-level I/O functions have
    a relatively high cost and the stardard I/O functions are designed to
    minimise the number of low-level I/O function calls, by doing some local
    buffering.

    As a result of this, it is trivially easy for the ignorant to slow down
    his I/O by one order of magnitude, while an expert can only speed up his
    I/O by a small percentage, by using the low-level functions instead of the
    standard ones and removing one level of buffering, when and where it is
    not necessary.

    >Can't low-level I/O functions do this case?


    Why bother?

    Dan
    --
    Dan Pop
    DESY Zeuthen, RZ group
    Email:
     
    Dan Pop, Apr 19, 2004
    #12
  13. cylin

    kal Guest

    > Use shifts and mask operations (bitwise AND) to extract the individual
    > bytes. The details depend on the byte order in which you want to write
    > to the file.


    IMHO one is better off using "htnl()." This will work fine so long as
    all you are writing are 32 bit values.
     
    kal, Apr 20, 2004
    #13
  14. kal <> spoke thus:

    > IMHO one is better off using "htnl()." This will work fine so long as
    > all you are writing are 32 bit values.


    I suspect you meant htonl().

    --
    Christopher Benson-Manica | I *should* know what I'm talking about - if I
    ataru(at)cyberspace.org | don't, I need to know. Flames welcome.
     
    Christopher Benson-Manica, Apr 20, 2004
    #14
  15. (kal) writes:

    >> Use shifts and mask operations (bitwise AND) to extract the individual
    >> bytes. The details depend on the byte order in which you want to write
    >> to the file.

    >
    > IMHO one is better off using "htnl()."


    Wheather such a non-standard method of doing things is preferable when a
    standard method exists is certainly debatable.

    Martin


    --
    ,--. Martin Dickopp, Dresden, Germany ,= ,-_-. =.
    / ,- ) http://www.zero-based.org/ ((_/)o o(\_))
    \ `-' `-'(. .)`-'
    `-. Debian, a variant of the GNU operating system. \_/
     
    Martin Dickopp, Apr 20, 2004
    #15
  16. cylin

    Richard Bos Guest

    Martin Dickopp <> wrote:

    > (Richard Bos) writes:
    >
    > > if (fwrite(buf, sizeof *buf, sizeof buf/sizeof *buf, outfile) !=
    > > sizeof buf/sizeof *buf) {
    > > puts("Handle a write error here.");
    > > }
    > > fclose(outfile);
    > > /* For critical applications, you should even check the return value
    > > of fclose(), but I rarely do this. */

    >
    > Why do you check the return value of `fwrite' then? Most operating
    > systems don't write immediately to the underlying device when `fwrite'
    > is called, but have some buffering mechanism. Therefore, an error is
    > far more likely to show up in `fclose' than in `fwrite' on such systems.


    Good question. Guess I'm just too used to interactive output.

    Richard
     
    Richard Bos, Apr 20, 2004
    #16
  17. cylin

    Richard Bos Guest

    Christopher Benson-Manica <> wrote:

    > kal <> spoke thus:
    >
    > > IMHO one is better off using "htnl()." This will work fine so long as
    > > all you are writing are 32 bit values.

    >
    > I suspect you meant htonl().


    And _I_ suspect that function is not ISO.

    Richard
     
    Richard Bos, Apr 20, 2004
    #17
  18. Richard Bos <> spoke thus:

    > And _I_ suspect that function is not ISO.


    Going off-topic doesn't have to mean making things up :)

    --
    Christopher Benson-Manica | I *should* know what I'm talking about - if I
    ataru(at)cyberspace.org | don't, I need to know. Flames welcome.
     
    Christopher Benson-Manica, Apr 20, 2004
    #18
  19. cylin

    kal Guest

    Christopher Benson-Manica <> wrote

    > > IMHO one is better off using "htnl()."

    >
    > I suspect you meant htonl().


    Yes, it is "htonl()." Thank you very much. It was my mistake.

    Are there any equivalent functions in the standard C library?

    Is there even the concept of byte ordering in C?
     
    kal, Apr 21, 2004
    #19
  20. cylin

    Dan Pop Guest

    In <> (kal) writes:

    >Christopher Benson-Manica <> wrote
    >
    >> > IMHO one is better off using "htnl()."

    >>
    >> I suspect you meant htonl().

    >
    >Yes, it is "htonl()." Thank you very much. It was my mistake.
    >
    >Are there any equivalent functions in the standard C library?


    Nope.

    >Is there even the concept of byte ordering in C?


    Nope. In theory the bits could be scattered all over the place, rather
    than being nicely grouped in bytes, i.e. the physical representation of
    a short could be:

    b0 b7 b5 sign b4 b3 b1 b10 | b2 b14 b8 b9 b6 b12 b13 b12
    ---------------------------+----------------------------
    first byte second byte

    as long as all the operations generate the specified results (and unsigned
    short replaces the sign bit by bit 15). Of course, this is not going
    to happen in practice, but the standard is perfectly happy with it.
    Some very popular (at the time) old architectures had glitches at the
    byte ordering level (neither big endian nor little endian for 32-bit
    integers) but they are gone now.

    Dan
    --
    Dan Pop
    DESY Zeuthen, RZ group
    Email:
     
    Dan Pop, Apr 21, 2004
    #20
    1. Advertising

Want to reply to this thread or ask your own question?

It takes just 2 minutes to sign up (and it's free!). Just click the sign up button to choose a username and then you can ask your own questions on the forum.
Similar Threads
  1. randy1200
    Replies:
    2
    Views:
    547
    randy1200
    May 17, 2005
  2. Albert Tu
    Replies:
    2
    Views:
    649
    Bengt Richter
    Jan 25, 2005
  3. Ron Eggler

    writing binary file (ios::binary)

    Ron Eggler, Apr 25, 2008, in forum: C++
    Replies:
    9
    Views:
    936
    James Kanze
    Apr 28, 2008
  4. scad
    Replies:
    4
    Views:
    958
    James Kanze
    May 28, 2009
  5. Jim
    Replies:
    6
    Views:
    736
Loading...

Share This Page