fread/fwrite

[empriser]

How to use fread/fwrite copy a file.
When reach file's end, fread return 0, I don't konw how many bytes
in buf.

[Richard Heathfield]

¬a\/b said:

<snip>

each data definition that not fixed the size is unportable

Why?

each operation to data operand not well definited is unportable

size_t is well-defined.

--
Richard Heathfield <http://www.cpax.org.uk >
Email: -www. +rjh@
Google users: <http://www.cpax.org.uk/prg/writings/googly.php>
"Usenet is a strange place" - dmr 29 July 1999

[santosh]

¬a/b wrote:

On Mon, 09 Jul 2007 08:19:40 +0100, Flash Gordon
<sp**@flash-gordon.me.ukwro te:

¬a\/b wrote, On 09/07/07 07:42:

<snip>

size_t is not portable because you all don't know the size it has
only uint8_t uint16_t uint32_t, uint64_t are portable

Rubbish. There is no guarantee that the types you are suggesting are
available (even assuming C99) so they are less portable than size_t
which is *guaranteed* to exist. size_t is also the type returned by
fread (the function being called above), so whatever it is a variable of
type size_t is *guaranteed* to be large enough.

each data definition that not fixed the size is unportable

How come then dynamically typed programming languages like Python and
Common Lisp are so portable and popular?

each operation to data operand not well definited is unportable

That's certainly true, but that's irrelevant to our discussion, since
size_t is well defined by the C Standard. What problems do you
specifically face when you use size_t?

[¬a\\/b]

On Mon, 09 Jul 2007 08:31:03 +0000, Richard Heathfield wrote:

>¬a\/b said:

>each data definition that not fixed the size is unportable

Why?

easy

>each operation to data operand not well definited is unportable

size_t is well-defined.

portable in my country means: i write a X language program;
that program run the same way in all machines
in the world that have a X language conform compiler

then you can argue how this program is portable
in the standard C language

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

int main(void)
{size_t z=0x2FFFF, h=0xFFFFFFFF;
z=z*z;
printf("Bits(si ze_t) 32 ?\n");

if(h<=0xFFFF||z <=h)
printf("No\n" );
else printf("Yes\n") ;

return 0;
}

because in each machine it could answer in a different way.
So what do you mean for the word "portable"? it is a meaningless word

in each machine where there are definitions like "size_t=num ber"
or where there are operations with size_t type variable =they are
not portable by definition (in each machine could be a different
result)

the problem is: size_t has different size each machine
but let it be size_t has 64 bits for all machine in the world
(or it is an memory only dipendent data type like a bignumber)

the problem could be for "*" function: can "*" function is the same in
all the machine and have the same result for the same operands?

the same for all other operators
the same for all UB and machine dipendent results
the same for all other "fixed all different size" data types

[Richard Heathfield]

¬a\/b said:

<snip>

portable in my country means: i write a X language program;
that program run the same way in all machines
in the world that have a X language conform compiler

then you can argue how this program is portable
in the standard C language

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

int main(void)
{size_t z=0x2FFFF, h=0xFFFFFFFF;

No, this isn't portable, because C doesn't guarantee size_t can store
values as high as 0x2FFFF.

The fact that you can write a non-portable program using size_t does not
mean size_t is not portable.

So what do you mean for the word "portable"?

I mean that the program will achieve the same computational objective,
regardless of the implementation used to translate it.

it is a meaningless word

To you, maybe, but not to me.

in each machine where there are definitions like "size_t=num ber"
or where there are operations with size_t type variable =they are
not portable by definition (in each machine could be a different
result)

Two levers can be of different lengths, yet both can provide leverage,
and you can use either to shift a rock. Just as the concept of
"leverage" is portable across levers, so the concept of object size is
portable across implementations - and size_t is the type with which we
measure object sizes.

--
Richard Heathfield <http://www.cpax.org.uk >
Email: -www. +rjh@
Google users: <http://www.cpax.org.uk/prg/writings/googly.php>
"Usenet is a strange place" - dmr 29 July 1999

[Walter Roberson]

In article <31************ *************** *****@4ax.com>, ¬a\\/b <[e-mail]:

>portable in my country means: i write a X language program;
that program run the same way in all machines
in the world that have a X language conform compiler

>then you can argue how this program is portable
in the standard C language

[...]

>because in each machine it could answer in a different way.

"running the same way" does not mean the same as "will
produce the same answer". For example, a program to print
out the current calendar time might have the same code
on all the systems, but it is going to produce a different
answer when run on each one of them.
--
I was very young in those days, but I was also rather dim.
-- Christopher Priest

[santosh]

¬a/b wrote:

On Mon, 09 Jul 2007 08:31:03 +0000, Richard Heathfield wrote:

size_t is well-defined.

portable in my country means: i write a X language program;
that program run the same way in all machines
in the world that have a X language conform compiler

then you can argue how this program is portable
in the standard C language

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

int main(void)
{size_t z=0x2FFFF, h=0xFFFFFFFF;

You can't expect to portably store arbitrarily large values. size_t
can store values in the range of 0 ... SIZE_MAX. What's ill-defined
about this?

z=z*z;

Here you're performing an arithmetic calculation without checking for
the possibility of wrap-around. Again results might vary across
implementations , but this is not exclusive to size_t types.

printf("Bits(si ze_t) 32 ?\n");

if(h<=0xFFFF||z <=h)

You're comparing objects which might not hold the values intended for
them.

printf("No\n" );
else printf("Yes\n") ;

return 0;
}

because in each machine it could answer in a different way.
So what do you mean for the word "portable"? it is a meaningless word

And in what way is this exclusive to size_t. This is true for all of
C's numeric types. Each type's size and range are implementation
dependant except that certain minimum values are guaranteed by the
Standard. That's the price you'll have to pay for using an efficient,
statically typed language.

<snip>

the problem is: size_t has different size each machine
but let it be size_t has 64 bits for all machine in the world
(or it is an memory only dipendent data type like a bignumber)

If you want a language with dynamically sized types, there're plenty
of them floating around. C was not defined to be such a language. On
the other hand, if you stick to what's guaranteed by the Standard, you
_can_ achieve a very high level of source code portability. The
problem is, you want guarantees the Standard is not providing.

<snip>

[Barry Schwarz]

On Mon, 09 Jul 2007 10:19:09 +0200, "¬a\\/b" <[e-mail]:
snip

>each data definition that not fixed the size is unportable
each operation to data operand not well definited is unportable

Well then, you must not use int either since there are a plethora of
16-bit and 32-bit implementations . You probably don't use char either
since we know sizeof(char) is 1 but we don't know anything about
CHAR_BIT other than it is at least 8.
Remove del for email

[Guru Jois]

On Jul 8, 11:25 pm, santosh <santosh....@gm ail.comwrote:

As far as online tutorials are concerned I'll recommend Steve Summit's
one:

<http://www.eskimo.com/~scs/cclass/>

Also he maintains the very useful C FAQ:

<http://www.c-faq.com/>

There's also a clc "wiki":

<http://clc-wiki.net/>

Other resources include:

<http://www.lysator.liu .se/c/>
<http://www.dinkumware. com/manuals/>
<http://www-ccs.ucsd.edu/c/>
<http://www.open-std.org/jtc1/sc22/wg14/ - Site for the draft
Standard.
<http://www.knosof.co.u k/cbook/cbook.html>
<http://www.cpax.org.uk/prg/portable/c/index.php>

Thanks Santhosh

[Guru Jois]

On Jul 8, 11:41 pm, Richard Heathfield <[e-mail].i nvalidwrote:

santosh said:

<snip>

As far as online tutorials are concerned I'll recommend Steve Summit's
one:

<http://www.eskimo.com/~scs/cclass/>

Please allow me to add the Tom Torfs tutorial URL:

<http://cprog.tomsweb.n et/cintro.html>

Tom used to be a regular (and highly respected) comp.lang.c contributor.
Then, one day, he asked a question about C99, and it transpired that he
was writing a C99 preprocessor. He has not been seen since.

--
Richard Heathfield <http://www.cpax.org.uk >
Email: -www. +rjh@
Google users: <http://www.cpax.org.uk/prg/writings/googly.php>
"Usenet is a strange place" - dmr 29 July 1999

Thanks to Richard too.

[CBFalconer]

Richard Heathfield wrote:

¬a\/b said:

<snip>

>each data definition that not fixed the size is unportable

Why?

>each operation to data operand not well definited is unportable

size_t is well-defined.

Hint: ¬a\/b is a known troll.

--
<http://www.cs.auckland .ac.nz/~pgut001/pubs/vista_cost.txt>
<http://www.securityfoc us.com/columnists/423>
<http://www.aaxnet.com/editor/edit043.html>
cbfalconer at maineline dot net

--
Posted via a free Usenet account from http://www.teranews.com