COMPGROUPS.NET | Search | Post Question | Groups | Stream | About | Register

understanding fgets()

  • Follow


I wrote this program which reads a file and prints it onto stdout
using fgets().

PROBLEM: fgets() reads line by line into an array. Lets say, in input
file, first line is longer than 2nd line. Then after reading first
line into array all characters read must be present in the array when
it reads 2nd line e.g.

1st line:  usenet
2nd line:  clc

after reading first line contents of array: usenet
(array is not memset()ed)
after reading second line contents of array: clc (why not clcnet)

which means /use/ of /usenet/ was not replaced by /clc/ but contents
of array were replaced/cleared. (slashes are used for readability
here, emphasizing single words).

QUESTION: My question is I did not clear array contents after one call
to fgets() then who did ?  fgets() ?



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

enum { FGETS_READ_MAX = 256 };

void print_file(FILE* p);

int main(void)
{
  const char* filename = "dp.conf";
  FILE* filep;

  filep = fopen(filename, "r");
  if(NULL == filep)
    {
      fprintf(stderr,"IN: %s @%d: ERROR opening file\n", __FILE__,
__LINE__);
      return EXIT_FAILURE;
    }

  print_file(filep);

  if(fclose(filep))
    {
      printf("IN: %s @%d: ERROR closing file\n", __FILE__, __LINE__);
    }

  return 0;
}



void print_file(FILE* p)
{
  char arrc[FGETS_READ_MAX + 2] = {0};

  while(fgets(arrc, FGETS_READ_MAX, p))
    {
      printf("\t::%s", arrc);
    }

  if(feof(p))
    {
      printf("Successful EoF EXIT :)\n");
    }
  else if(ferror(p))
    {
      printf("IN: %s @%d: ERROR reading file\n", __FILE__, __LINE__);
    }
  else
    {
      printf("OOPS! .. some other kind of issue ??\n");
    }

}



--
www.lispmachine.wordpress.com
find my email-ID @above blog
0
Reply arnuld.mizong (73) 7/26/2011 7:53:01 AM 

On Jul 26, 8:53=A0am, arnuld <arnuld.miz...@gmail.com> wrote:

> I wrote this program which reads a file and prints it onto stdout
> using fgets().
>
> PROBLEM: fgets() reads line by line into an array. Lets say, in input
> file, first line is longer than 2nd line. Then after reading first
> line into array all characters read must be present in the array when
> it reads 2nd line e.g.
>
> 1st line: =A0usenet
> 2nd line: =A0clc
>
> after reading first line contents of array: usenet
> (array is not memset()ed)
> after reading second line contents of array: clc (why not clcnet)

fgets terminates it's input with a nul char. So the array actually
holds

  "clc\0et\0"

printf(0ing the buffer stops at the first nul char

<snip>
0
Reply nick_keighley_nospam (4574) 7/26/2011 8:05:08 AM 


> On Jul 26, 1:05=A0pm, Nick Keighley <nick_keighley_nos...@hotmail.com> wr=
ote:

> fgets terminates it's input with a nul char. So the array actually
> holds
>
> =A0 "clc\0et\0"
> ..SNIP..

Thanks Nick. I think I am taking a U-turn from a C hater -> C (not
that good) -> C (brilliant) :)
0
Reply arnuld.mizong (73) 7/26/2011 9:25:59 AM 

Nick Keighley <nick_keighley_nospam@hotmail.com> writes:

> On Jul 26, 8:53 am, arnuld <arnuld.miz...@gmail.com> wrote:
>
>> I wrote this program which reads a file and prints it onto stdout
>> using fgets().
>>
>> PROBLEM: fgets() reads line by line into an array. Lets say, in input
>> file, first line is longer than 2nd line. Then after reading first
>> line into array all characters read must be present in the array when
>> it reads 2nd line e.g.
>>
>> 1st line:  usenet
>> 2nd line:  clc
>>
>> after reading first line contents of array: usenet
>> (array is not memset()ed)
>> after reading second line contents of array: clc (why not clcnet)
>
> fgets terminates it's input with a nul char. So the array actually
> holds
>
>   "clc\0et\0"

A detail: fgets retains the newline (when there is room for it) so the
first call most likely produced

  "usenet\n\0"

and the second one resulted in

  "clc\n\0t\n\0"

There has been some debate about whether fgets has permission to alter
the array elements beyond the null that it is obliged to write.
Whatever view you take on this point, it is unlikely that an
implementation will actually do this and therefore the presence of
"t\n\0" is a pretty sound bet.

<snip>
-- 
Ben.
0
Reply ben.usenet (6515) 7/26/2011 11:22:40 AM 

On Jul 26, 2:25=A0am, arnuld <arnuld.miz...@gmail.com> wrote:
> > On Jul 26, 1:05=A0pm, Nick Keighley <nick_keighley_nos...@hotmail.com> =
wrote:
> > fgets terminates it's input with a nul char. So the array actually
> > holds
>
> > =A0 "clc\0et\0"
> > ..SNIP..
>
> Thanks Nick. I think I am taking a U-turn from a C hater -> C (not
> that good) -> C (brilliant) :)

I guess it depends on what your doing. For example, say I want to
write a program that calculates the factorial of 1000!. I can do this
in line of Haskell and get the exact number. However, doing the exact
same thing in C would require a lot more work.
0
Reply cdalten (976) 7/26/2011 4:12:30 PM 

On Jul 26, 9:12=A0am, Chad <cdal...@gmail.com> wrote:
> On Jul 26, 2:25=A0am, arnuld <arnuld.miz...@gmail.com> wrote:
>
> > > On Jul 26, 1:05=A0pm, Nick Keighley <nick_keighley_nos...@hotmail.com=
> wrote:
> > > fgets terminates it's input with a nul char. So the array actually
> > > holds
>
> > > =A0 "clc\0et\0"
> > > ..SNIP..
>
> > Thanks Nick. I think I am taking a U-turn from a C hater -> C (not
> > that good) -> C (brilliant) :)
>
> I guess it depends on what your doing. For example, say I want to
> write a program that calculates the factorial of 1000!. I can do this
> in line of Haskell and get the exact number. However, doing the exact
> same thing in C would require a lot more work.

er *do this one line of Haskell*
0
Reply cdalten (976) 7/26/2011 4:15:00 PM 

Chad wrote:
) I guess it depends on what your doing. For example, say I want to
) write a program that calculates the factorial of 1000!. I can do this
) in line of Haskell and get the exact number. However, doing the exact
) same thing in C would require a lot more work.

Indeed.
You would have to locate and download a library for manipulating large
numbers, and then write so many lines of code, perhaps even ten or more.

Any more silly examples ?


SaSW, Willem
-- 
Disclaimer: I am in no way responsible for any of the statements
            made in the above text. For all I know I might be
            drugged or something..
            No I'm not paranoid. You all think I'm paranoid, don't you !
#EOT
0
Reply willem6 (255) 7/26/2011 4:21:33 PM 

On Jul 26, 9:21=A0am, Willem <wil...@toad.stack.nl> wrote:
> Chad wrote:
>
> ) I guess it depends on what your doing. For example, say I want to
> ) write a program that calculates the factorial of 1000!. I can do this
> ) in line of Haskell and get the exact number. However, doing the exact
> ) same thing in C would require a lot more work.
>
> Indeed.
> You would have to locate and download a library for manipulating large
> numbers, and then write so many lines of code, perhaps even ten or more.
>
> Any more silly examples ?
>
>

Nope.
0
Reply cdalten (976) 7/26/2011 4:35:26 PM 

On 7/26/2011 12:15 PM, Chad wrote:
> On Jul 26, 9:12 am, Chad<cdal...@gmail.com>  wrote:
>> On Jul 26, 2:25 am, arnuld<arnuld.miz...@gmail.com>  wrote:
>>
>>>> On Jul 26, 1:05 pm, Nick Keighley<nick_keighley_nos...@hotmail.com>  wrote:
>>>> fgets terminates it's input with a nul char. So the array actually
>>>> holds
>>
>>>>    "clc\0et\0"
>>>> ..SNIP..
>>
>>> Thanks Nick. I think I am taking a U-turn from a C hater ->  C (not
>>> that good) ->  C (brilliant) :)
>>
>> I guess it depends on what your doing. For example, say I want to
>> write a program that calculates the factorial of 1000!. I can do this
>> in line of Haskell and get the exact number. However, doing the exact
>> same thing in C would require a lot more work.
>
> er *do this one line of Haskell*

er *do this in one line of Haskell*.  :-)

-- 
Kenneth Brody
0
Reply kenbrody (1860) 7/26/2011 5:19:28 PM 

On 2011-07-26, arnuld <arnuld.mizong@gmail.com> wrote:
> PROBLEM: fgets() reads line by line into an array. Lets say, in input
> file, first line is longer than 2nd line. Then after reading first
> line into array all characters read must be present in the array when
> it reads 2nd line e.g.

Huh?

> 1st line:  usenet
> 2nd line:  clc

> after reading first line contents of array: usenet
> (array is not memset()ed)
> after reading second line contents of array: clc (why not clcnet)

No.

After reading first line, contents of array:  "usenet\0".

After reading second line, contents of array: "clc\0et\0".

-s
-- 
Copyright 2011, all wrongs reversed.  Peter Seebach / usenet-nospam@seebs.net
http://www.seebs.net/log/ <-- lawsuits, religion, and funny pictures
http://en.wikipedia.org/wiki/Fair_Game_(Scientology) <-- get educated!
I am not speaking for my employer, although they do rent some of my opinions.
0
Reply usenet-nospam (2199) 7/26/2011 6:42:12 PM 

Seebs <usenet-nospam@seebs.net> writes:

> On 2011-07-26, arnuld <arnuld.mizong@gmail.com> wrote:
>> PROBLEM: fgets() reads line by line into an array. Lets say, in input
>> file, first line is longer than 2nd line. Then after reading first
>> line into array all characters read must be present in the array when
>> it reads 2nd line e.g.
>
> Huh?
>
>> 1st line:  usenet
>> 2nd line:  clc
>
>> after reading first line contents of array: usenet
>> (array is not memset()ed)
>> after reading second line contents of array: clc (why not clcnet)
>
> No.
>
> After reading first line, contents of array:  "usenet\0".
>
> After reading second line, contents of array: "clc\0et\0".

You mean "usenet\n\0" then "clc\n\0t\n\0".

-- 
Ben.
0
Reply ben.usenet (6515) 7/26/2011 7:50:54 PM 

On 2011-07-26, Ben Bacarisse <ben.usenet@bsb.me.uk> wrote:
> Seebs <usenet-nospam@seebs.net> writes:
>> After reading first line, contents of array:  "usenet\0".

>> After reading second line, contents of array: "clc\0et\0".

> You mean "usenet\n\0" then "clc\n\0t\n\0".

A very charitable assumption, but no -- I meant what I said.  I was just
wrong.  :)

-s
-- 
Copyright 2011, all wrongs reversed.  Peter Seebach / usenet-nospam@seebs.net
http://www.seebs.net/log/ <-- lawsuits, religion, and funny pictures
http://en.wikipedia.org/wiki/Fair_Game_(Scientology) <-- get educated!
I am not speaking for my employer, although they do rent some of my opinions.
0
Reply usenet-nospam (2199) 7/26/2011 8:04:31 PM 

On Jul 26, 7:21=A0pm, Willem <wil...@toad.stack.nl> wrote:
> Chad wrote:
>
> ) I guess it depends on what your doing. For example, say I want to
> ) write a program that calculates the factorial of 1000!. I can do this
> ) in line of Haskell and get the exact number. However, doing the exact
> ) same thing in C would require a lot more work.
>
> Indeed.
> You would have to locate and download a library for manipulating large
> numbers, and then write so many lines of code, perhaps even ten or more.
>
> Any more silly examples ?
>
No, it's a fair point.

High precision maths libraries don't ship as standard in C. So you
have to locate a library, then install it, and that's often difficult.
Most people actually find it easier to incorporate most libraries as
source. There is often quite a bit of fiddling to do. Then it might
have declared bool and necessitate a rewriting of your own source.

It's also virtually impossible to read mathematical expressions when
the arithmetical operators are replaced with function calls.
0
Reply malcolm.mclean5 (722) 7/27/2011 8:03:23 AM 

[alt.lang.asm, comp.lang.c]
on a nice execise on factorial in assembly calling C functions

"Willem" <willem@toad.stack.nl> ha scritto nel messaggio
news:slrnj2tqcd.2dc9.willem@toad.stack.nl...
> Chad wrote:
> ) I guess it depends on what your doing. For example, say I want to
> ) write a program that calculates the factorial of 1000!. I can do this
> ) in line of Haskell and get the exact number. However, doing the exact
> ) same thing in C would require a lot more work.

How to find factorial of a number? i can find that only in hex :)

i don't know if it is right nor i remember all on how it calculate the result...
i just copy one 'old' nice exercise in my new pc change somethin in the code;
I checked only 20! that is right, do you know if 100! 1000! and 2000! below are
right?

;Nasmw  -fobj  thisFile.asm
;bcc32  -v     ThisFile.obj

section _DATA use32 public class=DATA

global _main
extern _printf
extern _fputc
extern _fgetc
extern _fclose
extern _fopen
extern _atoi
extern _ferror
extern _malloc
extern _free
extern _isspace
extern __streams

%define   _P  _printf

IIIthisProgInumberIn db "> thisProg number\n" , 13, 10, 0, 0
          IFindIoneIorImoreIerrorIn
db "Find one or more error" , 13, 10, 0, 0
          IITheIresultIisIinIhexIn
db " The result is in hex" , 13, 10, 0, 0

nl db 13, 10, 0, 0

section _BSS use32 public class=BSS
dbuffer resd 41792
section _TEXT use32 public class=CODE

;;
; fattoriale(u32*  out, u32  what)
; out is how to represent the big number
; out={32MemSizeIn32b, 32lenArrayIn32b, arrayOf32uns}
; Error: CF==1 /\ out.lenArray==0
; ok:    out is the big number result
; 0ra, 4P_out, 8P_what  + 32 + 32
; 68      72
;;
          align   4
fattoriale:
          pushad
          sub     esp,  32
          mov     ebx,  dword[esp+  68]
          mov     esi,  dword[esp+  72]
          cmp     ebx,  0
          je      .e
          cmp     esi,  -1
          je      .e
          cmp     dword[ebx],  0
          jle     .e
          mov     eax,  [ebx]
          mov     dword[ebx+4],  1
          mov     dword[ebx+8],  1
          mov     dword[esp+  0],  eax ; InibigNumber=1
          xor     edi,  edi
          xor     ebp,  ebp
          add     ebx,  8
          mov     ecx,  1
          cmp     esi,  0
          jl      .e
          jnz     .1
..a:       clc
          jmp     short  .z
..e:       mov     ebx,  dword[esp+  68]
          mov     dword[ebx+4],  0
          stc
          jmp     short  .z
; a[0], a[1], a[2], a[3], .... j resto prec
..1:       mov     eax,  [ebx]
          mul     esi
          mov     [ebx],  eax
          add     [ebx],  edi
          adc     edx,  0
          jc      .e
          mov     edi,  edx
          dec     ecx
          jz      .2
          inc     ebp
          cmp     ebp,  dword[esp+  0]
          jae     .e
          add     ebx,  4
          jmp     short  .1
..2:       cmp     edx,  0
          je      .3
          inc     ebp
          cmp     ebp,  dword[esp+  0]
          jae     .e
          add     ebx,  4
          mov     [ebx],  edx
..3:       mov     edi,  dword[esp+  68]
          xor     ebp,  ebp
          add     edi,  8
          mov     ecx,  ebx
          sub     ecx,  edi
          mov     ebx,  dword[esp+  68]
          shr     ecx,  2
          inc     ecx
          mov     edi,  0
          mov     dword[ebx+4],  ecx
          add     ebx,  8
          dec     esi
          cmp     esi,  1
          jg      .1
          clc
..z:
          lea     esp,  [esp+32]
          popad
          ret     8

;[32+20]52ra, 56P1, 60P2
          align   4
_main:
          pushad
          sub     esp,  20
          mov     ecx,  dword[esp+  56]
          mov     eax,  dword[esp+  60]
          mov     dword[esp+  12],  0 ; se c=1  r=a[0] il nome del file
          cmp     eax,  0
          jne     .1
..usage:   push    IIIthisProgInumberIn
          call    _P
          add     esp,  4
          jmp     .z
..error:   push    IFindIoneIorImoreIerrorIn
          call    _P
          add     esp,  4
          jmp     .z
..1:       cmp     ecx,  2
          jne     .usage
          mov     edi,  [eax+4]
          push    edi
          call    _atoi
          add     esp,  4
          cmp     edi,  10
          jle     .error
          mov     edi,  eax
          mov     ebx,  dbuffer
          mov     dword[ebx],  41782
          push    edi
          push    ebx
          call    fattoriale
          jc      .error
          mov     esi,  [ebx+4]
          cmp     esi,  0
          jle     .error
          dec     esi
          mov     edi,  esp
          mov     dword[esp],  "%x"
          mov     edx,  [ebx+4*esi+8]
          push    edx
          push    edi
          call    _P
          add     esp,  8
          mov     dword[esp],  "%08x"
          mov     dword[esp+4],  0
          jmp     short  .3
..2:       dec     esi
          mov     edx,  [ebx+4*esi+8]
          push    edx
          push    edi
          call    _P
          add     esp,  8
          cmp     eax,  0
          jl      .error
..3:       cmp     esi,  0
          ja      .2
          push    IITheIresultIisIinIhexIn
          call    _P
          add     esp,  4
..z:
          add     esp,  20
          popad
          xor     eax,  eax
          ret


---------
;Nasmw  -fobj  thisFile.asm
;bcc32  -v     ThisFile.obj

section _DATA use32 public class=DATA

global    _main
extern    _printf
extern    _fputc
extern    _fgetc
extern    _fclose
extern    _fopen
extern    _atoi
extern    _ferror
extern    _malloc
extern    _free
extern    _isspace
extern    __streams

%define   _P  _printf

"> thisProg number\n" db "> thisProg number\n",13,10,0,0
"Find one or more error\n"
db "Find one or more error",13,10,0,0
" The result is in hex\n"
db " The result is in hex",13, 10, 0, 0

nl        db   13, 10, 0, 0

section _BSS use32 public class=BSS
dbuffer resd    41792
section _TEXT use32 public class=CODE

;;
  fattoriale(u32*  out, u32  what)
  out is how to represent the big number
  out={32MemSizeIn32b, 32lenArrayIn32b, arrayOf32uns}
  Error: CF==1 /\ out.lenArray==0
  ok:    "out" is the number result
0ra, 4P_out, 8P_what  + 32 + 32
    68      72
;;
align  4
fattoriale:
pushad
s-=32
    b=^68  |i=^72
    b==0#.e|i==-1#.e|D*b<=0?#.e
    a=*b|D*b+4=1|D*b+8=1|^0=a    ; InibigNumber=1
    j^=j|k^=k|b+=8|c=1
    i<>0 |<?#.e|!#.1
..a:               clc|#.z
..e: b=^68|D*b+4=0|stc|#.z
 ; a[0], a[1], a[2], a[3], .... j resto prec
..1:   a=*b|mul i  |*b=a|*b+=j   |r++=0|jc .e
      j=r |--c!#.2| ++k|k>=^0#.e|b+=4 |#.1
..2:   r==0#.3|      ++k|k>=^0#.e|b+=4 |*b=r
..3:   j=^68|k^=k |j+=8|c=b|c-=j
      b=^68|c>>=2|++c |j=0|D*b+4=c
      b+=8|--i|i>1?#.1
      clc
..z:
s=&*s+32
popad
ret  8

;[32+20]52ra, 56P1, 60P2
align 4
_main:
pushad
s-=20
     c=^56|a=^60|^12=0   ; se c=1  r=a[0] il nome del file
     a==0!#.1
..usage:  _P<("> thisProg number\n" )    |##.z
..error:  _P<("Find one or more error\n")|##.z
..1:  c!=2#.usage
     j=*a+4|_atoi<(j)|j<=10?#.error|j=a
     b=dbuffer|D*b=41782|fattoriale(b, j)|jc  .error
     i=*b+4|i<=0?#.error|--i
     j=s|D*s="%x"|r=*b+4*i+8|_P<(j,r)
     D*s="%08x"  |D*s+4=0|#.3
..2:     --i|r=*b+4*i+8
        _P<(j, r)|a<0?#.error
..3:     i>0#.2
     _P<(" The result is in hex\n")
..z:
s+=20
popad
a^=a
ret

-------------------------
>hfattoriale  20
21c3677c82b40000 The result is in hex

>hfattoriale   100
1b30964ec395dc24069528d54bbda40d16e966ef9a70eb21b5b2943a321cdf103917
45570cca9420c6ecb3b72ed2ee8b02ea2735c61a000000000000000000000000
The result is in hex

>hfattoriale  1000
 2a2a773338969b740de6e2b291fd8dd6ee62a2b41525ab61cbe52489b6cf344c232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 The result is in hex

>hfattoriale  2000
 1fb792495d7d27c55cad76f8bbb39983874f2b4eafc67912c7ed6e04a68d463b99f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 The result is in hex
0
Reply io_x 7/27/2011 7:45:25 PM
comp.lang.c 29486 articles. 25 followers.

13 Replies
27 Views

(page loaded in 0.185 seconds)

Similiar Articles:

input & output in assembly - comp.lang.asm.x86
I was thinking of fgets() and fputs(). The gets() and puts() functions assume ... As I understand, 64-bit Windows will use this emulator to >>emulate DOS/Win16 ...

Only number input thru scanf() - comp.lang.c
I'd maybe use fgets() followed by sscanf(). This would also provide a trivial way ... I understand I input this into immediate ... to the right. ... [Www] is the week number ...

Finding common lines between text files - comp.unix.programmer ...
... Error: Unable to open %s\n", argv[1]); return 1; } // Read file 1 while (fgets ... If I understand the post-increment operator correctly, the above is equivalent to x[$0 ...

Neatest way to get the end pointer? - comp.lang.c
But even though I do understand it, it took a moment to think through weather or not it ... PHP: fgets - Manual fgetc() - Gets character from file pointer; stream_get_line ...

Scanf vs fgets | DaniWeb
I'm having some trouble understanding the advantages and disadvantages of using scanf over fgets. When we have allocated memory using an array for eg, it is not wise ...

C programming, while (fgets ( line, sizeof(line), ab ) != NULL) I ...
C programming, while (fgets ( line, sizeof(line), ab ) != NULL) I don't understand the length of line[]?

7/17/2012 8:16:19 AM


Reply:



Privacy Policy | All Times Are GMT(UTC) | powered by