Return to scanf CVS log

Up to [MW Coherent from dump] / coherent / a / usr / man / ALL

Annotation of coherent/a/usr/man/ALL/scanf, revision 1.1

1.1     ! root        1: 
        !             2: 
        !             3: scanf()                       STDIO                       scanf()
        !             4: 
        !             5: 
        !             6: 
        !             7: 
        !             8: Accept and format input
        !             9: 
        !            10: #include <stdio.h>
        !            11: iinntt ssccaannff(_f_o_r_m_a_t, _a_r_g_1, ... _a_r_g_N)
        !            12: cchhaarr *_f_o_r_m_a_t; [ddaattaa ttyyppee] *_a_r_g_1, ... *_a_r_g_N;
        !            13: 
        !            14: scanf reads  the standard  input, and  uses the string  format to
        !            15: specify a  format for each arg1 through argN,  each of which must
        !            16: be a pointer.
        !            17: 
        !            18: scanf  reads one  character at  a time  from format;  white space
        !            19: characters are ignored.  The percent sign character `%' marks the
        !            20: beginning of a  conversion specification.  `%' may be followed by
        !            21: characters that  indicate the  width of  the input field  and the
        !            22: type of conversion to be done.
        !            23: 
        !            24: scanf reads  the standard input until the  return key is pressed.
        !            25: Inappropriate characters  are thrown away; e.g.,  it will not try
        !            26: to write an alphabetic character into an iinntt.
        !            27: 
        !            28: The following modifiers can be used within the conversion string:
        !            29: 
        !            30: 11. The  asterisk `*', which  indicates that the  next input field
        !            31:    should be skipped rather than assigned to the next arg.
        !            32: 
        !            33: 22. A  string of decimal  digits, which specifies  a maximum field
        !            34:    width.
        !            35: 
        !            36: 33. An l,  which specifies that the next input  item is a long ob-
        !            37:    ject rather  than an int object.   Capitalizing the conversion
        !            38:    character has the same effect.
        !            39: 
        !            40: The following conversion specifiers are recognized:
        !            41: 
        !            42: cc  Assign the next input  character to the next arg, which should
        !            43:    be of type cchhaarr *.
        !            44: 
        !            45: dd  Assign  the decimal integer  from the next input  field to the
        !            46:    next arg, which should be of type iinntt *.
        !            47: 
        !            48: DD  Assign  the decimal integer  from the next input  field to the
        !            49:    next arg, which should be of type lloonngg *.
        !            50: 
        !            51: ee  Assign the floating point  number from the next input field to
        !            52:    the next  arg, which should be of type ffllooaatt *.
        !            53: 
        !            54: EE  Assign the floating point  number from the next input field to
        !            55:    the next  arg, which should be of type ddoouubbllee *.
        !            56: 
        !            57: ff  Same as ee.
        !            58: 
        !            59: FF  Same as EE.
        !            60: 
        !            61: 
        !            62: 
        !            63: 
        !            64: COHERENT Lexicon                                           Page 1
        !            65: 
        !            66: 
        !            67: 
        !            68: 
        !            69: scanf()                       STDIO                       scanf()
        !            70: 
        !            71: 
        !            72: 
        !            73: oo  Assign the octal integer from the next input field to the next
        !            74:    arg, which should be of type iinntt *.
        !            75: 
        !            76: OO  Assign the octal integer from the next input field to the next
        !            77:    arg, which should be of type lloonngg *.
        !            78: 
        !            79: ss  Assign the  string from the next input field  to the next arg,
        !            80:    which should be of type cchhaarr *.  The array to which the char *
        !            81:    points should  be long enough to accept the  string and a ter-
        !            82:    minating null character.
        !            83: 
        !            84: xx  Assign  the hexadecimal integer  from the next  input field to
        !            85:    the next arg, which should be of type iinntt *.
        !            86: 
        !            87: XX  Assign  the hexadecimal integer  from the next  input field to
        !            88:    the next arg, which should be of type lloonngg *.
        !            89: 
        !            90: It is important to remember that ssccaannff reads up, but not through,
        !            91: the newline character:  the newline remains in the standard input
        !            92: device's  buffer until  you dispose  of it  somehow.  Programmers
        !            93: have  been known  to forget  to empty  the buffer  before calling
        !            94: ssccaannff a second time, which leads to unexpected results.
        !            95: 
        !            96: ***** Example *****
        !            97: 
        !            98: The following  example uses  ssccaannff in  a brief dialogue  with the
        !            99: user.
        !           100: 
        !           101: 
        !           102: #include <stdio.h>
        !           103: 
        !           104: main()
        !           105: {
        !           106:         int left, right;
        !           107: 
        !           108: 
        !           109: 
        !           110:         printf("No. of fingers on your left hand:  ");
        !           111:         /* force message to appear on screen */
        !           112:         fflush(stdout);
        !           113:         scanf("%d", &left);
        !           114: 
        !           115: 
        !           116: 
        !           117:         /* eat newline char */
        !           118:         while(getchar() != '\n')
        !           119:                 ;
        !           120: 
        !           121: 
        !           122: 
        !           123:         printf("No. of fingers on your right hand:  ");
        !           124:         fflush(stdout);
        !           125:         scanf("%d", &right);
        !           126: 
        !           127: 
        !           128: 
        !           129: 
        !           130: COHERENT Lexicon                                           Page 2
        !           131: 
        !           132: 
        !           133: 
        !           134: 
        !           135: scanf()                       STDIO                       scanf()
        !           136: 
        !           137: 
        !           138: 
        !           139: 
        !           140: 
        !           141:         /* again, eat newline */
        !           142:         while(getchar() != '\n')
        !           143:                 ;
        !           144: 
        !           145: 
        !           146: 
        !           147:         printf("You've %d left fingers, %d right, & %d total\n",
        !           148:                 left, right, left+right);
        !           149: }
        !           150: 
        !           151: 
        !           152: ***** See Also *****
        !           153: 
        !           154: fscanf(), sscanf(), STDIO
        !           155: 
        !           156: ***** Diagnostics *****
        !           157: 
        !           158: scanf returns the number  of arguments filled.  It returns EOF if
        !           159: no arguments can be filled or if an error occurs.
        !           160: 
        !           161: ***** Notes *****
        !           162: 
        !           163: Because C does not perform type checking, it is essential that an
        !           164: argument match its specification.  For that reason, scanf is best
        !           165: used to process only data that you are certain are in the correct
        !           166: data format.  The  use of upper-case format characters to specify
        !           167: long arguments  is not  standard; use  the `l' modifier  for por-
        !           168: tability.
        !           169: 
        !           170: scanf is  difficult to use  correctly, and its misuse  can be as-
        !           171: sociated with  intermittent and dangerous bugs.   Rather than use
        !           172: scanf to  obtain a  string from  the keyboard: it  is recommended
        !           173: that you use gets to obtain  the string, and use strtok or sscanf
        !           174: to parse it.
        !           175: 
        !           176: 
        !           177: 
        !           178: 
        !           179: 
        !           180: 
        !           181: 
        !           182: 
        !           183: 
        !           184: 
        !           185: 
        !           186: 
        !           187: 
        !           188: 
        !           189: 
        !           190: 
        !           191: 
        !           192: 
        !           193: 
        !           194: 
        !           195: 
        !           196: COHERENT Lexicon                                           Page 3
        !           197: 
        !           198: 

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.