add directory Ref-docs
This commit is contained in:
gohigh
427
Ref-docs/C/lib_scan.html
Normal file
427
Ref-docs/C/lib_scan.html
Normal file
@@ -0,0 +1,427 @@
|
||||
<HTML><HEAD><TITLE>Formatted Input</TITLE></HEAD><BODY BGCOLOR="#FFFFFF">
|
||||
|
||||
<H1><A NAME="Formatted Input">Formatted Input</A></H1><HR>
|
||||
|
||||
<P><B><A HREF="#Scan Formats">Scan Formats</A>
|
||||
· <A HREF="#Scan Functions">Scan Functions</A>
|
||||
· <A HREF="#Scan Conversion Specifiers">Scan Conversion Specifiers</A>
|
||||
</B></P>
|
||||
<HR>
|
||||
|
||||
<P>Several library functions help you convert data values from
|
||||
text sequences that are generally readable by people to
|
||||
encoded internal representations. You provide a
|
||||
<A HREF="lib_prin.html#format string" tppabs="http://ccs.ucsd.edu/c/lib_prin.html#format string">format string</A> as the value of the
|
||||
<CODE>format</CODE> argument to each of these functions, hence
|
||||
the term <B>formatted input</B>. The functions fall
|
||||
into two categories:</P>
|
||||
|
||||
<UL>
|
||||
<LI>The <B><A NAME="byte scan functions">byte scan functions</A></B>
|
||||
(declared in
|
||||
<A HREF="stdio.html#<stdio.h>" tppabs="http://ccs.ucsd.edu/c/stdio.html#<stdio.h>"><CODE><stdio.h></CODE></A>)
|
||||
convert sequences of type <I>char</I> to internal representations,
|
||||
and help you scan such sequences that you read:
|
||||
<A HREF="stdio.html#fscanf" tppabs="http://ccs.ucsd.edu/c/stdio.html#fscanf">fscanf</A>,
|
||||
<A HREF="stdio.html#scanf" tppabs="http://ccs.ucsd.edu/c/stdio.html#scanf">scanf</A>, and
|
||||
<A HREF="stdio.html#sscanf" tppabs="http://ccs.ucsd.edu/c/stdio.html#sscanf">sscanf</A>.
|
||||
For these function, a format string is a
|
||||
<A HREF="lib_over.html#multibyte string" tppabs="http://ccs.ucsd.edu/c/lib_over.html#multibyte string">multibyte string</A>
|
||||
that begins and ends in the
|
||||
<A HREF="charset.html#initial shift state" tppabs="http://ccs.ucsd.edu/c/charset.html#initial shift state">initial shift state</A>.
|
||||
|
||||
<LI>The <B><A NAME="wide scan functions">wide scan functions</A></B>
|
||||
(declared in
|
||||
<A HREF="wchar.html#<wchar.h>" tppabs="http://ccs.ucsd.edu/c/wchar.html#<wchar.h>"><CODE><wchar.h></CODE></A>
|
||||
and hence added with
|
||||
<B><A HREF="lib_over.html#Amendment 1" tppabs="http://ccs.ucsd.edu/c/lib_over.html#Amendment 1">Amendment 1</A></B>)
|
||||
convert sequences of type
|
||||
<A HREF="stddef.html#wchar_t" tppabs="http://ccs.ucsd.edu/c/stddef.html#wchar_t"><CODE>wchar_t</CODE></A>,
|
||||
to internal representations,
|
||||
and help you scan such sequences that you read:
|
||||
<A HREF="wchar.html#fwscanf" tppabs="http://ccs.ucsd.edu/c/wchar.html#fwscanf">fwscanf</A>,
|
||||
<A HREF="wchar.html#wscanf" tppabs="http://ccs.ucsd.edu/c/wchar.html#wscanf">wscanf</A> and
|
||||
<A HREF="wchar.html#swscanf" tppabs="http://ccs.ucsd.edu/c/wchar.html#swscanf">swscanf</A>.
|
||||
For these functions, a format string is a
|
||||
<A HREF="lib_over.html#wide-character string" tppabs="http://ccs.ucsd.edu/c/lib_over.html#wide-character string">wide-character string</A>.
|
||||
In the descriptions that follow, a wide character <CODE>wc</CODE>
|
||||
from a format string or a stream is compared to a specific (byte)
|
||||
character <CODE>c</CODE> as if by evaluating the expression
|
||||
<CODE><A HREF="wchar.html#wctob" tppabs="http://ccs.ucsd.edu/c/wchar.html#wctob">wctob</A>(wc) == c</CODE>.
|
||||
</UL>
|
||||
|
||||
<H2><A NAME="Scan Formats">Scan Formats</A></H2>
|
||||
|
||||
<P>A format string has the same general
|
||||
<B><A HREF="lib_prin.html#format string" tppabs="http://ccs.ucsd.edu/c/lib_prin.html#format string">syntax</A></B>
|
||||
for the scan functions as for the
|
||||
<A HREF="lib_prin.html#Formatted Output" tppabs="http://ccs.ucsd.edu/c/lib_prin.html#Formatted Output">print functions</A>:
|
||||
zero or more
|
||||
<B><A HREF="lib_prin.html#conversion specification" tppabs="http://ccs.ucsd.edu/c/lib_prin.html#conversion specification">
|
||||
conversion specifications</A></B>,
|
||||
interspersed with literal text and
|
||||
<B><A HREF="lib_prin.html#white space" tppabs="http://ccs.ucsd.edu/c/lib_prin.html#white space">white space</A></B>.
|
||||
For the scan functions, however, a conversion specification is one of the
|
||||
<A HREF="#scan conversion specification">
|
||||
scan conversion specifications</A> described below.</P>
|
||||
|
||||
<P>A scan function scans the format string once from beginning
|
||||
to end to determine what conversions to perform. Every scan
|
||||
function accepts a
|
||||
<A HREF="stdarg.html#varying number of arguments" tppabs="http://ccs.ucsd.edu/c/stdarg.html#varying number of arguments">varying number
|
||||
of arguments</A>, either directly or under control of an argument of type
|
||||
<A HREF="stdarg.html#va_list" tppabs="http://ccs.ucsd.edu/c/stdarg.html#va_list"><CODE>va_list</CODE></A>.
|
||||
Some scan conversion specifications
|
||||
in the format string use the next argument in the list.
|
||||
A scan function uses each successive argument no more than
|
||||
once. Trailing arguments can be left unused.</P>
|
||||
|
||||
<P>In the description that follows, the
|
||||
<A HREF="lib_prin.html#integer conversions" tppabs="http://ccs.ucsd.edu/c/lib_prin.html#integer conversions">integer conversions</A> and
|
||||
<A HREF="lib_prin.html#floating-point conversions" tppabs="http://ccs.ucsd.edu/c/lib_prin.html#floating-point conversions">
|
||||
floating-point conversions</A> are the same as for the
|
||||
<A HREF="lib_prin.html#Formatted Output" tppabs="http://ccs.ucsd.edu/c/lib_prin.html#Formatted Output">print functions</A>.</P>
|
||||
|
||||
<H2><A NAME="Scan Functions">Scan Functions</A></H2>
|
||||
|
||||
<P>For the scan functions, literal text in a format string must
|
||||
match the next characters to scan in the input text.
|
||||
<A HREF="lib_prin.html#white space" tppabs="http://ccs.ucsd.edu/c/lib_prin.html#white space">White space</A> in
|
||||
a format string must match the longest possible sequence of the next
|
||||
zero or more white-space characters in the input. Except for the
|
||||
<A HREF="#Scan Conversion Specifiers">
|
||||
scan conversion specifier</A>
|
||||
<A HREF="#%n"><CODE>%n</CODE></A>
|
||||
(which consumes no input), each
|
||||
<B><A NAME="scan conversion specification">
|
||||
scan conversion specification</A></B>
|
||||
determines a pattern that one or more of the next characters in the
|
||||
input must match. And except for the
|
||||
<A HREF="#Scan Conversion Specifiers">
|
||||
scan conversion specifiers
|
||||
<A HREF="#%c"><CODE>c</CODE></A>,
|
||||
<A HREF="#%n"><CODE>n</CODE></A>, and
|
||||
<A HREF="#%["><CODE>[</CODE></A>,
|
||||
every match begins by skipping any
|
||||
<A HREF="lib_prin.html#%n" tppabs="http://ccs.ucsd.edu/c/lib_prin.html#%n">white space</A> characters in the input.</P>
|
||||
|
||||
<P>A scan function returns when:</P>
|
||||
|
||||
<UL>
|
||||
<LI>it reaches the terminating null in the format string
|
||||
|
||||
<LI>it cannot obtain additional input characters to scan
|
||||
(<B><A NAME="input failure">input failure</A></B>)
|
||||
|
||||
<LI>a conversion fails
|
||||
(<B><A NAME="matching failure">matching failure</A></B>)
|
||||
</UL>
|
||||
|
||||
<P>A scan function returns
|
||||
<A HREF="stdio.html#EOF" tppabs="http://ccs.ucsd.edu/c/stdio.html#EOF"><CODE>EOF</CODE></A>
|
||||
if an input failure occurs before any conversion. Otherwise it returns
|
||||
the number of converted values stored. If one or more characters form
|
||||
a valid prefix but the conversion fails, the valid prefix is consumed
|
||||
before the scan function returns. Thus:</P>
|
||||
|
||||
<PRE>
|
||||
scanf("%i", &i) <B>consumes 0X from the field 0XZ</B>
|
||||
scanf("%f", &f) <B>consumes 3.2E from the field 3.2EZ</B></PRE>
|
||||
|
||||
<P>A scan conversion specification typically converts the matched input
|
||||
characters to a corresponding encoded value. The next argument value
|
||||
must be the address of an object. The conversion converts the encoded
|
||||
representation (as necessary) and stores its value in the object.
|
||||
A scan conversion specification has the format:</P>
|
||||
|
||||
<P><IMG SRC="scan.gif" tppabs="http://ccs.ucsd.edu/c/gif/scan.gif"></P>
|
||||
|
||||
<P>Following the percent character (<B><CODE>%</CODE></B>)
|
||||
in the format string, you can write an asterisk (<B><CODE>*</CODE></B>)
|
||||
to indicate that the conversion should not store
|
||||
the converted value in an object.</P>
|
||||
|
||||
<P>Following any <CODE>*</CODE>, you can write a nonzero
|
||||
<B><A NAME="scan field width">field width</A></B>
|
||||
that specifies the maximum number of input characters
|
||||
to match for the conversion (not counting any
|
||||
<A HREF="lib_prin.html#white space" tppabs="http://ccs.ucsd.edu/c/lib_prin.html#white space">white space</A> that the
|
||||
pattern can first skip).</P>
|
||||
|
||||
<H2><A NAME="Scan Conversion Specifiers">Scan Conversion Specifiers</A></H2>
|
||||
|
||||
<P>Following any
|
||||
<A HREF="#scan field width">field width</A>,
|
||||
you must write a one-character <B>scan conversion specifier</B>,
|
||||
either a one-character code or a
|
||||
<A HREF="#scan set">scan set</A>,
|
||||
possibly preceded by a one-character qualifier.
|
||||
Each combination determines the type required of the
|
||||
next argument (if any) and how
|
||||
the scan functions interpret the text sequence and converts it to
|
||||
an encoded value.
|
||||
The <A HREF="lib_prin.html#integer conversions" tppabs="http://ccs.ucsd.edu/c/lib_prin.html#integer conversions">integer</A> and
|
||||
<A HREF="lib_prin.html#floating-point conversions" tppabs="http://ccs.ucsd.edu/c/lib_prin.html#floating-point conversions">
|
||||
floating-point conversions</A> also determine
|
||||
what base to assume for the text representation. (The base is
|
||||
the <CODE>base</CODE> argument to the functions
|
||||
<A HREF="stdlib.html#strtol" tppabs="http://ccs.ucsd.edu/c/stdlib.html#strtol"><CODE>strtol</CODE></A> and
|
||||
<A HREF="stdlib.html#strtoul" tppabs="http://ccs.ucsd.edu/c/stdlib.html#strtoul"><CODE>strtoul</CODE></A>.)
|
||||
The following table lists all defined combinations and
|
||||
their properties.</P>
|
||||
|
||||
<PRE><B>
|
||||
Conversion Argument Conversion
|
||||
Specifier Type Function Base</B>
|
||||
%c char x[]
|
||||
%lc wchar_t x[]
|
||||
%d int *x strtol 10
|
||||
%hd short *x strtol 10
|
||||
%ld long *x strtol 10
|
||||
%e float *x strtod 10
|
||||
%le double *x strtod 10
|
||||
%Le long double *x strtod 10
|
||||
%E float *x strtod 10
|
||||
%lE double *x strtod 10
|
||||
%LE long double *x strtod 10
|
||||
%f float *x strtod 10
|
||||
%lf double *x strtod 10
|
||||
%Lf long double *x strtod 10
|
||||
%g float *x strtod 10
|
||||
%lg double *x strtod 10
|
||||
%Lg long double *x strtod 10
|
||||
%G float *x strtod 10
|
||||
%lG double *x strtod 10
|
||||
%LG long double *x strtod 10
|
||||
%i int *x strtol 0
|
||||
%hi short *x strtol 0
|
||||
%li long *x strtol 0
|
||||
%n int *x
|
||||
%hn short *x
|
||||
%ln long *x
|
||||
%o unsigned int *x strtoul 8
|
||||
%ho unsigned short *x strtoul 8
|
||||
%lo unsigned long *x strtoul 8
|
||||
%p void **x
|
||||
%s char x[]
|
||||
%ls wchar_t x[]
|
||||
%u unsigned int *x strtoul 10
|
||||
%hu unsigned short *x strtoul 10
|
||||
%lu unsigned long *x strtoul 10
|
||||
%x unsigned int *x strtoul 16
|
||||
%hx unsigned short *x strtoul 16
|
||||
%lx unsigned long *x strtoul 16
|
||||
%X unsigned int *x strtoul 16
|
||||
%hX unsigned short *x strtoul 16
|
||||
%lX unsigned long *x strtoul 16
|
||||
%[...] char x[]
|
||||
%l[...] wchar_t x[]
|
||||
%% <B>none</B></PRE>
|
||||
|
||||
<P>The scan conversion specifier (or
|
||||
<A HREF="#scan set">scan set</A>) determines any behavior
|
||||
not summarized in this table. In the following descriptions,
|
||||
examples follow each of the scan conversion specifiers.
|
||||
In each example, the function
|
||||
<A HREF="stdio.html#sscanf" tppabs="http://ccs.ucsd.edu/c/stdio.html#sscanf"><CODE>sscanf</CODE></A>
|
||||
matches the <B><CODE>bold</CODE></B> characters.</P>
|
||||
|
||||
<P>You write <B><A NAME="%c"><CODE>%c</CODE></A></B>
|
||||
to store the matched input characters in
|
||||
an array object. If you specify no field width <I>w,</I> then <I>w</I>
|
||||
has the value one. The match does not skip leading
|
||||
<A HREF="lib_prin.html#white space" tppabs="http://ccs.ucsd.edu/c/lib_prin.html#white space">white space</A>. Any
|
||||
sequence of <I>w</I> characters matches the conversion pattern. For a
|
||||
<A HREF="lib_file.html#wide stream" tppabs="http://ccs.ucsd.edu/c/lib_file.html#wide stream">wide stream</A>,
|
||||
conversion occurs as if by repeatedly calling
|
||||
<A HREF="wchar.html#wcrtomb" tppabs="http://ccs.ucsd.edu/c/wchar.html#wcrtomb"><CODE>wcrtomb</CODE></A>,
|
||||
beginning in the
|
||||
<A HREF="charset.html#initial conversion state" tppabs="http://ccs.ucsd.edu/c/charset.html#initial conversion state">
|
||||
initial conversion state</A>.</P>
|
||||
|
||||
<PRE>
|
||||
sscanf("<B>1</B>29E-2", "%c", &c) <B>stores '1'</B>
|
||||
sscanf("<B>12</B>9E-2", "%2c", &c[0]) <B>stores '1', '2'</B>
|
||||
swscanf(L"<B>1</B>29E-2", L"%c", &c) <B>stores '1'</B></PRE>
|
||||
|
||||
<P>You write <B><A NAME="%lc"><CODE>%lc</CODE></A></B>
|
||||
to store the matched input characters in an array object,
|
||||
with elements of type
|
||||
<A HREF="stddef.html#wchar_t" tppabs="http://ccs.ucsd.edu/c/stddef.html#wchar_t">wchar_t</A>.
|
||||
If you specify no field width <I>w,</I> then <I>w</I>
|
||||
has the value one. The match does not skip leading
|
||||
<A HREF="lib_prin.html#white space" tppabs="http://ccs.ucsd.edu/c/lib_prin.html#white space">white space</A>. Any
|
||||
sequence of <I>w</I> characters matches the conversion pattern. For a
|
||||
<A HREF="lib_file.html#byte stream" tppabs="http://ccs.ucsd.edu/c/lib_file.html#byte stream">byte stream</A>,
|
||||
conversion occurs as if by repeatedly calling
|
||||
<A HREF="wchar.html#wcrtomb" tppabs="http://ccs.ucsd.edu/c/wchar.html#wcrtomb"><CODE>mbrtowc</CODE></A>, beginning in the
|
||||
<A HREF="charset.html#initial conversion state" tppabs="http://ccs.ucsd.edu/c/charset.html#initial conversion state">
|
||||
initial conversion state</A>.</P>
|
||||
|
||||
<PRE>
|
||||
sscanf("<B>1</B>29E-2", "%lc", &c) <B>stores L'1'</B>
|
||||
sscanf("<B>12</B>9E-2", "%2lc", &c) <B>stores L'1', L'2'</B>
|
||||
swscanf(L"<B>1</B>29E-2", L"%lc", &c) <B>stores L'1'</B></PRE>
|
||||
|
||||
<P>You write <B><A NAME="%d"><CODE>%d</CODE></A></B>,
|
||||
<B><A NAME="%i"><CODE>%i</CODE></A></B>,
|
||||
<B><A NAME="%o"><CODE>%o</CODE></A></B>,
|
||||
<B><A NAME="%u"><CODE>%u</CODE></A></B>,
|
||||
<B><A NAME="%x"><CODE>%x</CODE></A></B>, or
|
||||
<B><A NAME="%X"><CODE>%X</CODE></A></B> to convert
|
||||
the matched input characters as a signed integer
|
||||
and store the result in an integer object.</P>
|
||||
|
||||
<PRE>
|
||||
sscanf("<B>129E</B>-2", "%o%d%x", &i, &j, &k) <B>stores 10, 9, 14</B></PRE>
|
||||
|
||||
<P>You write <B><A NAME="%e"><CODE>%e</CODE></A></B>,
|
||||
<B><A NAME="%E"><CODE>%E</CODE></A></B>,
|
||||
<B><A NAME="%f"><CODE>%f</CODE></A></B>,
|
||||
<B><A NAME="%g"><CODE>%g</CODE></A></B>, or
|
||||
<B><A NAME="%G"><CODE>%G</CODE></A></B>
|
||||
to convert the matched input characters as a signed fraction, with
|
||||
an optional exponent, and store the result in a floating-point object.</P>
|
||||
|
||||
<PRE>
|
||||
sscanf("<B>129E-2</B>", "%e", &f) <B>stores 1.29</B></PRE>
|
||||
|
||||
<P>You write <B><A NAME="%n"><CODE>%n</CODE></A></B>
|
||||
to store the number of characters
|
||||
matched (up to this point in the format) in an integer object. The
|
||||
match does not skip leading
|
||||
<A HREF="lib_prin.html#white space" tppabs="http://ccs.ucsd.edu/c/lib_prin.html#white space">white space</A>
|
||||
and does not match any input characters.</P>
|
||||
|
||||
<PRE>
|
||||
sscanf("<B>12</B>9E-2", "12%n", &i) <B>stores 2</B></PRE>
|
||||
|
||||
<P>You write <B><A NAME="%p"><CODE>%p</CODE></A></B>
|
||||
to convert the matched input characters as
|
||||
an external representation of a <I>pointer to void</I> and store the
|
||||
result in an object of type <I>pointer to void.</I> The input characters
|
||||
must match the form generated by the
|
||||
<A HREF="lib_prin.html#%p" tppabs="http://ccs.ucsd.edu/c/lib_prin.html#%p"><CODE>%p</CODE>
|
||||
<A HREF="lib_prin.html#print conversion specification" tppabs="http://ccs.ucsd.edu/c/lib_prin.html#print conversion specification">
|
||||
print conversion specification</A>.</P>
|
||||
|
||||
<PRE>
|
||||
sscanf("<B>129E</B>-2", "%p", &p) <B>stores, e.g. 0x129E</B></PRE>
|
||||
|
||||
<P>You write <B><A NAME="%s"><CODE>%s</CODE></A></B>
|
||||
to store the matched input characters in
|
||||
an array object, followed by a terminating null character. If you
|
||||
do not specify a field width <I>w,</I> then <I>w</I> has a large value.
|
||||
Any sequence of up to <I>w</I> non white-space characters matches
|
||||
the conversion pattern. For a
|
||||
<A HREF="lib_file.html#wide stream" tppabs="http://ccs.ucsd.edu/c/lib_file.html#wide stream">wide stream</A>,
|
||||
conversion occurs as if by repeatedly calling
|
||||
<CODE>wcrtomb</CODE> beginning in the
|
||||
<A HREF="charset.html#initial conversion state" tppabs="http://ccs.ucsd.edu/c/charset.html#initial conversion state">
|
||||
initial conversion state</A>.</P>
|
||||
|
||||
<PRE>
|
||||
sscanf("<B>129E-2</B>", "%s", &s[0]) <B>stores "129E-2"</B>
|
||||
swscanf(L"<B>129E-2</B>", L"%s", &s[0]) <B>stores "129E-2"</B></PRE>
|
||||
|
||||
<P>You write <B><A NAME="%ls"><CODE>%ls</CODE></A></B>
|
||||
to store the matched input characters in
|
||||
an array object, with elements of type
|
||||
<A HREF="stddef.html#wchar_t" tppabs="http://ccs.ucsd.edu/c/stddef.html#wchar_t">wchar_t</A>,
|
||||
followed by a terminating null wide character. If you
|
||||
do not specify a field width <I>w,</I> then <I>w</I> has a large value.
|
||||
Any sequence of up to <I>w</I> non white-space characters matches
|
||||
the conversion pattern. For a
|
||||
<A HREF="lib_file.html#byte stream" tppabs="http://ccs.ucsd.edu/c/lib_file.html#byte stream">byte stream</A>,
|
||||
conversion occurs as if by repeatedly calling
|
||||
<A HREF="wchar.html#mbrtowc" tppabs="http://ccs.ucsd.edu/c/wchar.html#mbrtowc"><CODE>mbrtowc</CODE></A>,
|
||||
beginning in the
|
||||
<A HREF="charset.html#initial conversion state" tppabs="http://ccs.ucsd.edu/c/charset.html#initial conversion state">
|
||||
initial conversion state</A>.</P>
|
||||
|
||||
<PRE>
|
||||
sscanf("<B>129E-2</B>", "%ls", &s[0]) <B>stores L"129E-2"</B>
|
||||
swscanf(L"<B>129E-2</B>", L"%ls", &s[0]) <B>stores L"129E-2"</B></PRE>
|
||||
|
||||
<P>You write <B><A NAME="%["><CODE>%[</CODE></A></B>
|
||||
to store the matched input characters in
|
||||
an array object, followed by a terminating null character. If you
|
||||
do not specify a field width <I>w,</I> then <I>w</I> has a large value.
|
||||
The match does not skip leading
|
||||
<A HREF="lib_prin.html#white space" tppabs="http://ccs.ucsd.edu/c/lib_prin.html#white space">white space</A>.
|
||||
A sequence of up to <I>w</I>
|
||||
characters matches the conversion pattern in the
|
||||
<B><A NAME="scan set">scan set</A></B> that follows.
|
||||
To complete the scan set, you follow the left bracket
|
||||
(<CODE>[</CODE>) in the conversion specification with a sequence
|
||||
of zero or more <B>match</B> characters, terminated by a right bracket
|
||||
(<B><CODE>]</CODE></B>).</P>
|
||||
|
||||
<P>If you do not write a caret (<B><CODE>^</CODE></B>)
|
||||
immediately after the <CODE>[</CODE>, then each
|
||||
input character must match <I>one</I> of the match
|
||||
characters. Otherwise, each input character must not match <I>any</I>
|
||||
of the match characters, which begin with the character following
|
||||
the <CODE>^</CODE>. If you write a <B><CODE>]</CODE></B>
|
||||
immediately after the <CODE>[</CODE> or <CODE>[^</CODE>,
|
||||
then the <CODE>]</CODE> is the first match character, not
|
||||
the terminating <CODE>]</CODE>. If you write a minus
|
||||
(<B><CODE>-</CODE></B>) as other than the first or last match character,
|
||||
an implementation can give it special meaning.
|
||||
It usually indicates a range of characters, in conjunction with the
|
||||
characters immediately preceding or following, as in
|
||||
<CODE>0-9</CODE> for all the digits.)
|
||||
You cannot specify a null match character.</P>
|
||||
|
||||
<P> For a <A HREF="lib_file.html#wide stream" tppabs="http://ccs.ucsd.edu/c/lib_file.html#wide stream">wide stream</A>,
|
||||
conversion occurs as if by repeatedly calling
|
||||
<A HREF="wchar.html#wcrtomb" tppabs="http://ccs.ucsd.edu/c/wchar.html#wcrtomb"><CODE>wcrtomb</CODE></A>,
|
||||
beginning in the
|
||||
<A HREF="charset.html#initial conversion state" tppabs="http://ccs.ucsd.edu/c/charset.html#initial conversion state">
|
||||
initial conversion state</A>.</P>
|
||||
|
||||
<PRE>
|
||||
sscanf("<B>12</B>9E-2", "[54321]", &s[0]) <B>stores "12"</B>
|
||||
swscanf(L"<B>12</B>9E-2", L"[54321]", &s[0]) <B>stores "12"</B></PRE>
|
||||
|
||||
<P>You write <B><A NAME="%l["><CODE>%l[</CODE></A></B>
|
||||
to store the matched input characters in
|
||||
an array object, with elements of type
|
||||
<A HREF="stddef.html#wchar_t" tppabs="http://ccs.ucsd.edu/c/stddef.html#wchar_t">wchar_t</A>,
|
||||
followed by a terminating null wide character. If you
|
||||
do not specify a field width <I>w,</I> then <I>w</I> has a large value.
|
||||
The match does not skip leading
|
||||
<A HREF="lib_prin.html#white space" tppabs="http://ccs.ucsd.edu/c/lib_prin.html#white space">.
|
||||
A sequence of up to <I>w</I>
|
||||
characters matches the conversion pattern in the
|
||||
<A HREF="#scan set">scan set</A> that follows.
|
||||
|
||||
<P> For a <A HREF="lib_file.html#byte stream" tppabs="http://ccs.ucsd.edu/c/lib_file.html#byte stream">byte stream</A>,
|
||||
conversion occurs as if by repeatedly calling
|
||||
<A HREF="wchar.html#mbrtowc" tppabs="http://ccs.ucsd.edu/c/wchar.html#mbrtowc"><CODE>mbrtowc</CODE></A>,
|
||||
beginning in the
|
||||
<A HREF="charset.html#initial conversion state" tppabs="http://ccs.ucsd.edu/c/charset.html#initial conversion state">
|
||||
initial conversion state</A>.</P>
|
||||
|
||||
<PRE>
|
||||
sscanf("<B>12</B>9E-2", "l[54321]", &s[0]) <B>stores L"12"</B>
|
||||
swscanf(L"<B>12</B>9E-2", L"l[54321]", &s[0]) <B>stores L"12"</B></PRE>
|
||||
|
||||
<P>You write <B><A NAME="%%"><CODE>%%</CODE></A></B>
|
||||
to match the percent character (<CODE>%</CODE>).
|
||||
The function does not store a value.</P>
|
||||
|
||||
<PRE>
|
||||
sscanf("<B>% 0XA</B>", "%% %i") <B>stores 10</B></PRE>
|
||||
|
||||
<HR>
|
||||
<P>See also the
|
||||
<B><A HREF="index.html#Table of Contents" tppabs="http://ccs.ucsd.edu/c/index.html#Table of Contents">Table of Contents</A></B> and the
|
||||
<B><A HREF="_index.html" tppabs="http://ccs.ucsd.edu/c/_index.html">Index</A></B>.</P>
|
||||
|
||||
<P><I>
|
||||
<A HREF="crit_pb.html" tppabs="http://ccs.ucsd.edu/c/crit_pb.html">Copyright</A> © 1989-1996
|
||||
by P.J. Plauger and Jim Brodie. All rights reserved.</I></P>
|
||||
|
||||
</BODY></HTML>
|
||||
|
||||
Reference in New Issue
Block a user