write a binary file?

[cylin]

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(szFile Name,O_CREAT|O_ BINARY|O_TRUNC| O_WRONLY,S_IREA D|S_IWRITE);
UCHAR buffer[5]; //???????????
write(iFD,buffe r,5);
---------------------------------------------------

Thanks.

Regards,
cylin.

[Richard Bos]

"cylin" <cy***@avant.co m.tw> 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(szFile Name,O_CREAT|O_ BINARY|O_TRUNC| O_WRONLY,S_IREA D|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,buffe r,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=fope n(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

[Irrwahn Grausewitz]

"cylin" <cy***@avant.co m.tw> 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(szFile Name,O_CREAT|O_ BINARY|O_TRUNC| O_WRONLY,S_IREA D|S_IWRITE);
UCHAR buffer[5]; //???????????
write(iFD,buff er,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 (ir*******@free net.de)
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

[Martin Dickopp]

"cylin" <cy***@avant.co m.tw> 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(szFile Name,O_CREAT|O_ BINARY|O_TRUNC| O_WRONLY,S_IREA D|S_IWRITE);
No such function in standard C. Use `fopen'.
UCHAR buffer[5]; //???????????
write(iFD,buffe r,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]

rl*@hoekstra-uitgeverij.nl (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]

Martin Dickopp <ex************ ****@zero-based.org> 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. \_/

[cylin]

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.

[Martin Dickopp]

"cylin" <cy***@avant.co m.tw> 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. \_/

[Joona I Palaste]

cylin <cy***@avant.co m.tw> 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 (pa*****@cc.hel sinki.fi) ------------- Finland --------\
\-- http://www.helsinki.fi/~palaste --------------------- rules! --------/
"C++ looks like line noise."
- Fred L. Baube III

[CBFalconer]

Martin Dickopp wrote:

"cylin" <cy***@avant.co m.tw> 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)