字符处理函数ctype.h和wctype.h

最新推荐文章于 2022-09-03 20:27:07 发布
最新推荐文章于 2022-09-03 20:27:07 发布
阅读量1.6k 收藏 1
点赞数
分类专栏： C标准库浅析
本文介绍了字符处理函数ctype.h和宽字符处理函数wctype.h的标准属性判断与转换函数。包括ASCII字符分类、转换函数实现原理及宽字符集的分类转换。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

原文出自：http://blog.csdn.net/zhoudaxia/article/details/4634338



字符处理包括分类（即属性判断）和转换函数。ASCII字符主要可分类为控制字符、空白字符、可打印字符、数字字符、字母字符（大写和小写）、标点符号等。

    1、ctype.h：标准的属性判断函数有isalnum,isalpha,iscntrl,isdigit,isxdigit,isgraph,isprint,ispunct,islower,isupper,isspace, isblank（C99中引入）共12个函数。标准的属性转换函数有tolower和toupper。当然具体的实现中还会提供一些非标准函数作为扩展，如glibc的实现中提供了isctype,isascii,toascii。
[cpp] view plain copy
  1. /* ISO C99 Standard 7.4: 字符处理   <ctype.h> */  
  2. #ifndef _CTYPE_H  
  3. #define _CTYPE_H    1  
  4. #include <features.h>   /* 定义了一些表示编译选项的宏 */  
  5. #include <bits/types.h>  
  6. __BEGIN_DECLS  
  7. #ifndef _ISbit  
  8. /* 下面这些是所有的字符属性，如果超过16种不同的属性，那很多使用unsigned short int的 
  9.     的函数代码都要改变。这些属性被存储为网络字节序（大端字节序），我们为每个属性定义一个 
  10.     依赖于机器字节序的比特位解释 */  
  11. # include <endian.h>  
  12. # if __BYTE_ORDER == __BIG_ENDIAN  /* 如果是大端字节序 */  
  13. #  define _ISbit(bit)   (1 << (bit))  
  14. # else /* 否则__BYTE_ORDER==__LITTLE_ENDIAN，是小端字节序 */  
  15. #  define _ISbit(bit)   ((bit) < 8 ? ((1 << (bit)) << 8) : ((1 << (bit)) >> 8))  
  16. # endif  
  17. enum  
  18. {  
  19.   _ISupper = _ISbit (0),    /* 大写字母字符A~Z：0x41~0x5A  */  
  20.   _ISlower = _ISbit (1),    /* 小写字母字符a~z：0x61~0x7A  */  
  21.   _ISalpha = _ISbit (2),    /* 字母字符A~Za~z  */  
  22.   _ISdigit = _ISbit (3),    /* 十进制数字字符0~9：0x30~0x39  */  
  23.   _ISxdigit = _ISbit (4),   /* 十六进制数字字符0~9A~Fa~f  */  
  24.   _ISspace = _ISbit (5),    /* 空白字符：0x9~0xD,0x20。包括水平制表符/t，换行符/n， 
  25.                                        垂直制表符/v，换页符/f，回车符/r，空格符' '  */  
  26.   _ISprint = _ISbit (6),    /* 可打印字符：0x20~0x7E。即任何非控制字符  */  
  27.   _ISgraph = _ISbit (7),    /* 图形字符：除空格以外的可打印字符  */  
  28.   _ISblank = _ISbit (8),    /* 空白分隔符：通常是空格符和水平制表符(Space和Tab键)  */  
  29.   _IScntrl = _ISbit (9),    /* 控制字符：0x0~0x1F,0x7F  */  
  30.   _ISpunct = _ISbit (10),   /* 标点符号  */  
  31.   _ISalnum = _ISbit (11)    /* 字母和数字字符  */  
  32. };  
  33. #endif /* ! _ISbit  */  
  34. /* 这些函数定义在ctype-info.c中。这里的描述必须与localeinfo.h中的一致。 
  35.     在依赖于线程的区域模型中（参看<local.h>中的uselocale），我们不能像过去那样对这些 
  36.     函数使用全局变量，现在这些访问函数返回每个变量的地址，这是多线程环境中当前线程的本 
  37.     地地址。 
  38.     这些指针指向一个大小为384的数组中，因此它们可以通过以下几种下标值来访问：任何[0,255]内的 
  39.    unsigend char值；EOF(-1)；任何[-128,-1)内的signed char值。ISO C要求ctype中 
  40.     的函数工作在unsigend char或EOF上；这里我们同时也支持负的signed char值以兼容老的程序。 
  41.     大小写转换数组是int的，而不是unsigned char，因为tolower(EOF)的结果必须是EOF，这并不 
  42.     是一个unsigned char。但是今天更重要的是数组也会在多字节字符集中使用 */  
  43. extern __const unsigned short int **__ctype_b_loc (void)  
  44.      __attribute__ ((__const));  
  45. extern __const __int32_t **__ctype_tolower_loc (void)  
  46.      __attribute__ ((__const));  
  47. extern __const __int32_t **__ctype_toupper_loc (void)  
  48.      __attribute__ ((__const));  
  49. #define __isctype(c, type) /  
  50.   ((*__ctype_b_loc ())[(int) (c)] & (unsigned short int) type)  
  51. #define __isascii(c)    (((c) & ~0x7f) == 0) /* 如果C是一个7比特的值，说明是一个ascii字符(0~127)  */  
  52. #define __toascii(c)    ((c) & 0x7f)        /* 屏蔽掉高位  */  
  53. /* 用宏来声明ctype中的各个函数原型，以简化代码 */  
  54. #define __exctype(name) extern int name (int) __THROW  
  55. __BEGIN_NAMESPACE_STD  
  56. /* 下面的名称是所有的函数： 
  57.    int isCHARACTERISTIC(int c);  
  58.    当且仅当C有属性CHARACTERISTIC时返回非0值（真），  
  59.    对CHARACTERISTIC名称的含义，参看上面的enum 
  60.    函数形参是一个字符，用int类型描述 */  
  61. __exctype (isalnum);  /* 这里是各个函数原型声明 */  
  62. __exctype (isalpha);  
  63. __exctype (iscntrl);  
  64. __exctype (isdigit);  
  65. __exctype (islower);  
  66. __exctype (isgraph);  
  67. __exctype (isprint);  
  68. __exctype (ispunct);  
  69. __exctype (isspace);  
  70. __exctype (isupper);  
  71. __exctype (isxdigit);  
  72. /* 返回C的小写形式  */  
  73. extern int tolower (int __c) __THROW;  
  74. /* 返回C的大写形式  */  
  75. extern int toupper (int __c) __THROW;  
  76. __END_NAMESPACE_STD  
  77.   
  78. /* ISO C99引入了一个新函数  */  
  79. #ifdef  __USE_ISOC99  
  80. __BEGIN_NAMESPACE_C99  
  81. __exctype (isblank);  
  82. __END_NAMESPACE_C99  
  83. #endif  
  84. #ifdef __USE_GNU  
  85. /* 根据掩码MASK来测试C是否属于某个字符集  */  
  86. extern int isctype (int __c, int __mask) __THROW;  
  87. #endif  
  88. #if defined __USE_SVID || defined __USE_MISC || defined __USE_XOPEN  
  89. /* 返回非0值，当且仅当C是ASCII字符集中（例如，不足7比特的宽度）  */  
  90. extern int isascii (int __c) __THROW;  
  91. /* 返回C中在ASCII字符集中的那部分（例如，C的低位7比特）  */  
  92. extern int toascii (int __c) __THROW;  
  93. /* 下面的原型与toupper和tolower相同，唯一不同的它们不检查实参是否在char的范围内 */  
  94. __exctype (_toupper);  
  95. __exctype (_tolower);  
  96. #endif /* Use SVID or use misc.  */  
  97. /* 下面代码用于优化的转换函数中 */  
  98. #define __tobody(c, f, a, args) /  
  99.   (__extension__                                  /  
  100.    ({ int __res;                                  /  
  101.       if (sizeof (c) > 1)                              /  
  102.     {                                     /  
  103.       if (__builtin_constant_p (c))                       /  
  104.         {                                     /  
  105.           int __c = (c);                              /  
  106.           __res = __c < -128 || __c > 255 ? __c : (a)[__c];             /  
  107.         }                                     /  
  108.       else                                    /  
  109.         __res = f args;                           /  
  110.     }                                     /  
  111.       else                                    /  
  112.     __res = (a)[(int) (c)];                           /  
  113.       __res; }))  
  114. #if !defined __NO_CTYPE && !defined __cplusplus  
  115. # define isalnum(c) __isctype((c), _ISalnum)  
  116. # define isalpha(c) __isctype((c), _ISalpha)  
  117. # define iscntrl(c) __isctype((c), _IScntrl)  
  118. # define isdigit(c) __isctype((c), _ISdigit)  
  119. # define islower(c) __isctype((c), _ISlower)  
  120. # define isgraph(c) __isctype((c), _ISgraph)  
  121. # define isprint(c) __isctype((c), _ISprint)  
  122. # define ispunct(c) __isctype((c), _ISpunct)  
  123. # define isspace(c) __isctype((c), _ISspace)  
  124. # define isupper(c) __isctype((c), _ISupper)  
  125. # define isxdigit(c)    __isctype((c), _ISxdigit)  
  126. # ifdef __USE_ISOC99  
  127. #  define isblank(c)    __isctype((c), _ISblank)  
  128. # endif  
  129. # ifdef __USE_EXTERN_INLINES  
  130. __extern_inline int  
  131. __NTH (tolower (int __c))  
  132. {  
  133.   return __c >= -128 && __c < 256 ? (*__ctype_tolower_loc ())[__c] : __c;  
  134. }  
  135. __extern_inline int  
  136. __NTH (toupper (int __c))  
  137. {  
  138.   return __c >= -128 && __c < 256 ? (*__ctype_toupper_loc ())[__c] : __c;  
  139. }  
  140. # endif  
  141. # if __GNUC__ >= 2 && defined __OPTIMIZE__ && !defined __cplusplus  
  142. #  define tolower(c)    __tobody (c, tolower, *__ctype_tolower_loc (), (c))  
  143. #  define toupper(c)    __tobody (c, toupper, *__ctype_toupper_loc (), (c))  
  144. # endif /* Optimizing gcc */  
  145. # if defined __USE_SVID || defined __USE_MISC || defined __USE_XOPEN  
  146. #  define isascii(c)    __isascii (c)  
  147. #  define toascii(c)    __toascii (c)  
  148. #  define _tolower(c)   ((int) (*__ctype_tolower_loc ())[(int) (c)])  
  149. #  define _toupper(c)   ((int) (*__ctype_toupper_loc ())[(int) (c)])  
  150. # endif  
  151. #endif /* Not __NO_CTYPE.  */  
  152. /* 下面是GNU对各个属性分类函数和转换函数的扩展接口，每个函数有一个对应的扩展版本， 
  153.     增加了一个参数用来传递区域设置 */  
  154.       
  155. /* ...... */  
  156. __END_DECLS  
  157. #endif /* ctype.h  */  
[cpp] view plain copy
  1. /* ctype.c：各个字符处理函数的实现  */  
  2. #define __NO_CTYPE  
  3. #include <ctype.h>  
  4. /* 为所有的ctype宏提供实际的函数实现  */  
  5. #define func(name, type) /  
  6.   int name (int c) { return __isctype (c, type); }  
  7. func (isalnum, _ISalnum)  
  8. func (isalpha, _ISalpha)  
  9. func (iscntrl, _IScntrl)  
  10. func (isdigit, _ISdigit)  
  11. func (islower, _ISlower)  
  12. func (isgraph, _ISgraph)  
  13. func (isprint, _ISprint)  
  14. func (ispunct, _ISpunct)  
  15. func (isspace, _ISspace)  
  16. func (isupper, _ISupper)  
  17. func (isxdigit, _ISxdigit)  
  18. #define __ctype_tolower /  
  19.   ((int32_t *) _NL_CURRENT (LC_CTYPE, _NL_CTYPE_TOLOWER) + 128)  
  20. #define __ctype_toupper /  
  21.   ((int32_t *) _NL_CURRENT (LC_CTYPE, _NL_CTYPE_TOUPPER) + 128)  
  22. int  
  23. tolower (int c)  
  24. {  
  25.   return c >= -128 && c < 256 ? __ctype_tolower[c] : c;  
  26. }  
  27. int  
  28. toupper (int c)  
  29. {  
  30.   return c >= -128 && c < 256 ? __ctype_toupper[c] : c;  
  31. }  

    解释：
    （1）字符的所有属性类被封装在一个enum中，每个属性对应一个枚举常量。
    （2）在作为接口的头文件中，由于各个函数的类型相同，都接受int型字符，返回int型的值，因此原型声明可用宏__exctype(name)来完成，name为函数名，这样可以简化代码。
    （3）所有的属性判断函数的实现都是用宏__isctype(c, type)和返回数组指针的外部函数__ctype_b_loc()来完成。在实现文件ctype.c中可以看到，所有的判断函数都只有一条语句“return __isctype (c, type);”。这个函数式宏用来判断字符c是否具有属性type（为枚举常量），它直接以字符c为下标，获得__ctype_b_loc()数组相应位置处的元素，并与属性作逻辑与运算，若结果为非0，说明字符具有该属性，若结果为0则说明字符没有该属性。__ctype_b_loc()函数在glibc库的ctype-info.c文件中定义，它直接使用了glibc 2.0中已经实现的内置函数。可见，这里用宏来实现ctype，使之可以扩展，增加任意的属性。当然，我们也可以自己来实现这些属性函数，代码都很简单，只要判断其ASCII编码范围即可。
    （4）ctype.c中的tolower和toupper函数实现使用了宏__ctype_tolower，这个宏会被映射成一个数组。它直接根据字符c的范围__ctype_tolower[c]或c本身。
    （5）ctype.h下面的优化实现用于需要优化的环境中（比如用带优化选项的gcc来编译）。它直接把属性判断函数定义为宏，宏体就是__isctype (c, type)。定义成宏时就少了一层函数调用。tolower和toupper根据需要，或者用外部函数__ctype_tolower_loc()和__ctype_toupper_loc()来实现，并实现成内联函数；或者直接定义成宏，用这里定义的__tobody(c, f, a, args)来实现。这两者都差不多，因为内联函数也相当于具有宏的特征。
    （6）__BEGIN_DECLS/__END_DECLS宏用来表示数据结构、全局变量、函数原型声明的开始和结束。这类似于MFC中的BEGIN_MESSAGE_MAP/END_MESSAGE_MAP。__BEGIN_NAMESPACE_STD/__END_NAMESPACE_STD宏表示C标准库函数原型声明的开始和结束。__BEGIN_NAMESPACE_C99/__END_NAMESPACE_C99表示C99标准中的函数声明。
   2、wctype.h：C89增补1中引入，是ctype.h中各个函数的宽字符处理版本，能对宽字符进行属性分类和转换。还定义了通用属性类型wctype_t，表示字符转换的类型wctrans_t，构造属性的函数wctype，测试属性的通用函数iswctype，构造转换的函数wctrans，实行转换的通用函数towctrans。

[cpp] view plain copy
  1. /* ISO C99 Standard: 7.25  宽字符分类和转换函数   <wctype.h>  */  
  2. #ifndef _WCTYPE_H  
  3. #include <features.h>  
  4. #include <bits/types.h>  
  5. #ifndef __need_iswxxx  
  6. # define _WCTYPE_H  1  
  7. /* 从<wchar.h>中获取wint_t类型  */  
  8. # define __need_wint_t  
  9. # include <wchar.h>  
  10. /* wint_t类型的常量表达式，其值不是扩展字符集的任何成员 */  
  11. # ifndef WEOF  
  12. #  define WEOF (0xffffffffu)  
  13. # endif  
  14. #endif  
  15. #undef __need_iswxxx  
  16. /* 当<wcsmbs.h>在Unix98兼容的代码中使用时，下面部分也会在<wcsmbs.h>头文件中被使用 */  
  17. #ifndef __iswxxx_defined  
  18. # define __iswxxx_defined   1  
  19. __BEGIN_NAMESPACE_C99  
  20. /* 标量类型，该类型的值表示特定区域字符的分类 */  
  21. typedef unsigned long int wctype_t;   
  22. __END_NAMESPACE_C99  
  23. # ifndef _ISwbit  
  24. /* 这些属性总是被存储为网络字节序（大端字节）。我们为每个属性定义一个 
  25.     依赖于机器字节序的比特位解释 */  
  26. #  include <endian.h>  
  27. #  if __BYTE_ORDER == __BIG_ENDIAN  
  28. #   define _ISwbit(bit) (1 << (bit))  
  29. #  else /* 否则__BYTE_ORDER==__LITTLE_ENDIAN，是小端字节序 */  
  30. #   define _ISwbit(bit) /  
  31.     ((bit) < 8 ? (int) ((1UL << (bit)) << 24)                  /  
  32.      : ((bit) < 16 ? (int) ((1UL << (bit)) << 8)               /  
  33.         : ((bit) < 24 ? (int) ((1UL << (bit)) >> 8)                /  
  34.            : (int) ((1UL << (bit)) >> 24))))  
  35. #  endif  
  36. enum  
  37. {  
  38.   __ISwupper = 0,           /* 大写宽字符 */  
  39.   __ISwlower = 1,           /* 小写宽字符  */  
  40.   __ISwalpha = 2,           /* 字母宽字符  */  
  41.   __ISwdigit = 3,           /* 十进制数字宽字符  */  
  42.   __ISwxdigit = 4,          /* 十六进制数字宽字符  */  
  43.   __ISwspace = 5,           /* 空白宽字符  */  
  44.   __ISwprint = 6,           /* 可打印宽字符  */  
  45.   __ISwgraph = 7,           /* 图形宽字符  */  
  46.   __ISwblank = 8,           /* 空白分隔宽字符：通常是空格符和水平制表符(Space和Tab键)  */  
  47.   __ISwcntrl = 9,           /* 控制宽字符  */  
  48.   __ISwpunct = 10,          /* 标点符号宽字符  */  
  49.   __ISwalnum = 11,          /* 字母和数字宽字符  */  
  50.   _ISwupper = _ISwbit (__ISwupper), /* UPPERCASE.  */  
  51.   _ISwlower = _ISwbit (__ISwlower), /* lowercase.  */  
  52.   _ISwalpha = _ISwbit (__ISwalpha), /* Alphabetic.  */  
  53.   _ISwdigit = _ISwbit (__ISwdigit), /* Numeric.  */  
  54.   _ISwxdigit = _ISwbit (__ISwxdigit),   /* Hexadecimal numeric.  */  
  55.   _ISwspace = _ISwbit (__ISwspace), /* Whitespace.  */  
  56.   _ISwprint = _ISwbit (__ISwprint), /* Printing.  */  
  57.   _ISwgraph = _ISwbit (__ISwgraph), /* Graphical.  */  
  58.   _ISwblank = _ISwbit (__ISwblank), /* Blank (usually SPC and TAB).  */  
  59.   _ISwcntrl = _ISwbit (__ISwcntrl), /* Control character.  */  
  60.   _ISwpunct = _ISwbit (__ISwpunct), /* Punctuation.  */  
  61.   _ISwalnum = _ISwbit (__ISwalnum)  /* Alphanumeric.  */  
  62. };  
  63. # endif /* Not _ISwbit  */  
  64.   
  65. __BEGIN_DECLS  
  66. __BEGIN_NAMESPACE_C99  
  67. /* 
  68.  * 宽字符分类函数: 7.15.2.1. 
  69.  */  
  70. /* 测试c是否是字母或数字宽字符，等价于iswalpha(c) || iswdigit(c) */  
  71. extern int iswalnum (wint_t __wc) __THROW;  
  72. /* 测试c是否是特定区域设置的字母宽字符，在iswlower(c)或isupper(c)为真时取值为真， 
  73.     在iswcntrl(c),iswdigit(c),iswpunct(c)或iswspace(c)为真时取值为假 */  
  74. extern int iswalpha (wint_t __wc) __THROW;  
  75. /* 测试是否是控制型的宽字符  */  
  76. extern int iswcntrl (wint_t __wc) __THROW;  
  77. /* 测试是否是十进制的数字宽字符  */  
  78. extern int iswdigit (wint_t __wc) __THROW;  
  79. /* 测试是否是图形宽字符，等价于iswprint(c) && !iswspace(c)  */  
  80. extern int iswgraph (wint_t __wc) __THROW;  
  81. /* 测试是否是小写宽字符，等价于!iswcntrl(c) && !iswdigit(c) && !iswpunct(c)  
  82.    && !iswspace(c) */  
  83. extern int iswlower (wint_t __wc) __THROW;  
  84. /* 测试是否是可打印宽字符  */  
  85. extern int iswprint (wint_t __wc) __THROW;  
  86. /* 测试是否是标点符号宽字符，等价于iswprint(c) && !iswalnum(c) && !iswspace(c)  */  
  87. extern int iswpunct (wint_t __wc) __THROW;  
  88. /* 测试是否是空白宽字符，等价于!iswalnum(c) && !iswgraph(c) && !ispunct(c)  */  
  89. extern int iswspace (wint_t __wc) __THROW;  
  90. /* 测试是否是大写宽字符，等价于!iswcntrl(c) && !iswdigit(c) && !iswpunct(c)  
  91.    && !iswspace(c) */  
  92. extern int iswupper (wint_t __wc) __THROW;  
  93. /* 测试是否是十六进制的数字宽字符  */  
  94. extern int iswxdigit (wint_t __wc) __THROW;  
  95. /* 测试是否是空白分隔宽字符  */  
  96. # ifdef __USE_ISOC99  
  97. extern int iswblank (wint_t __wc) __THROW;  
  98. # endif  
  99. /* 
  100.  * 可扩展的宽字符分类函数： 7.15.2.2. 
  101.  */  
  102. /* 构造一个wctype_t类型的值，表示由字符串PROPERTY标识的宽字符类 */  
  103. extern wctype_t wctype (__const char *__property) __THROW;  
  104. /* 确定宽字符WC是否是DESC所标识的宽字符类 */  
  105. extern int iswctype (wint_t __wc, wctype_t __desc) __THROW;  
  106. __END_NAMESPACE_C99  
  107. /* 
  108.  * 宽字符的大小写转换函数： 7.15.3.1. 
  109.  */  
  110. __BEGIN_NAMESPACE_C99  
  111. /* 标量类型，该类型的值表示特定区域的宽字符转换 */  
  112. typedef __const __int32_t *wctrans_t;  
  113. __END_NAMESPACE_C99  
  114. #ifdef __USE_GNU  
  115. __USING_NAMESPACE_C99(wctrans_t)  
  116. #endif  
  117. __BEGIN_NAMESPACE_C99  
  118. /* 把大写宽字符转换成对应的小写宽字符  */  
  119. extern wint_t towlower (wint_t __wc) __THROW;  
  120. /* 把小写宽字符成对应的大写宽字符 */  
  121. extern wint_t towupper (wint_t __wc) __THROW;  
  122. __END_NAMESPACE_C99  
  123. __END_DECLS  
  124. #endif  /* need iswxxx.  */  
  125.   
  126. /* 剩下的定义和声明一定不能出现在<wcsmbs.h>中 */  
  127. #ifdef _WCTYPE_H  
  128. /* 
  129.  * 可扩展的宽字符转换函数： 7.15.3.2. 
  130.  */  
  131. __BEGIN_DECLS  
  132. __BEGIN_NAMESPACE_C99  
  133. /* 构造一个wctrans_t类型的值，表示由字符串PROPERTY标识的宽字符转换 */  
  134. extern wctrans_t wctrans (__const char *__property) __THROW;  
  135. /* 使用DESC所示的转换来对宽字符WC进行转换 */  
  136. extern wint_t towctrans (wint_t __wc, wctrans_t __desc) __THROW;  
  137. __END_NAMESPACE_C99  
  138. /* 下面是GNU对各个分类函数和转换函数的扩展接口，每个函数有一个对应的扩展版本， 
  139.     增加了一个参数用来传递区域设置 */  
  140.       
  141. /* ...... */  
  142. __END_DECLS  
  143. #endif  /* __WCTYPE_H defined.  */  
  144. #endif /* wctype.h  */  
[cpp] view plain copy
  1. /* wcfuncs.c：各个宽字符处理函数的实现 */  
  2. #include <ctype.h>  
  3. #include <wctype.h>  
  4. #include <locale/localeinfo.h>  
  5. #include "wchar-lookup.h"  
  6. /* 为所有wctype的原型提供实际的函数实现  */  
  7. #define func(name, type)                              /  
  8.   extern int __isw##name (wint_t __wc);                       /  
  9.   int                                         /  
  10.   __isw##name (wint_t wc)                             /  
  11.   {                                       /  
  12.     if (isascii (wc))                                 /  
  13.       return is##name ((int) wc);                         /  
  14.     size_t i = _NL_CURRENT_WORD (LC_CTYPE, _NL_CTYPE_CLASS_OFFSET) + type;    /  
  15.     const char *desc = _NL_CURRENT (LC_CTYPE, i);                 /  
  16.     return wctype_table_lookup (desc, wc);                    /  
  17.   }                                       /  
  18.   weak_alias (__isw##name, isw##name)  
  19. #undef iswalnum  
  20. func (alnum, __ISwalnum)  
  21. libc_hidden_weak (iswalnum)  
  22. #undef iswalpha  
  23. func (alpha, __ISwalpha)  
  24. libc_hidden_weak (iswalpha)  
  25. #undef iswblank  
  26. func (blank, __ISwblank)  
  27. #undef iswcntrl  
  28. func (cntrl, __ISwcntrl)  
  29. #undef iswdigit  
  30. func (digit, __ISwdigit)  
  31. libc_hidden_weak (iswdigit)  
  32. #undef iswlower  
  33. func (lower, __ISwlower)  
  34. libc_hidden_weak (iswlower)  
  35. #undef iswgraph  
  36. func (graph, __ISwgraph)  
  37. #undef iswprint  
  38. func (print, __ISwprint)  
  39. #undef iswpunct  
  40. func (punct, __ISwpunct)  
  41. #undef iswspace  
  42. func (space, __ISwspace)  
  43. libc_hidden_weak (iswspace)  
  44. #undef iswupper  
  45. func (upper, __ISwupper)  
  46. #undef iswxdigit  
  47. func (xdigit, __ISwxdigit)  
  48. libc_hidden_weak (iswxdigit)  
  49. #undef towlower  
  50. /* towlower函数的实现 */  
  51. wint_t  
  52. towlower (wc)  
  53.      wint_t wc;  
  54. {  
  55.   /* 获取区域设置表中当前区域类别的索引 */  
  56.   size_t i = _NL_CURRENT_WORD (LC_CTYPE, _NL_CTYPE_MAP_OFFSET) + __TOW_tolower;  
  57.   /* 根据索引，获取当前区域设置类别的描述字符串 */  
  58.   const char *desc = _NL_CURRENT (LC_CTYPE, i);  
  59.   return wctrans_table_lookup (desc, wc); /* 搜索位表，以获得转换后的宽字符，并返回 */  
  60. }  
  61. libc_hidden_def (towlower)  
  62. #undef towupper  
  63. /* towupper函数的实现 */  
  64. wint_t  
  65. towupper (wc)  
  66.      wint_t wc;  
  67. {  
  68.   /* 获取区域设置表中当前区域类别的索引 */  
  69.   size_t i = _NL_CURRENT_WORD (LC_CTYPE, _NL_CTYPE_MAP_OFFSET) + __TOW_toupper;  
  70.   /* 根据索引，获取当前区域设置类别的描述字符串 */  
  71.   const char *desc = _NL_CURRENT (LC_CTYPE, i);  
  72.   return wctrans_table_lookup (desc, wc); /* 搜索位表，以获得转换后的宽字符，并返回 */  
  73. }  
  74. libc_hidden_def (towupper)  

   解释：
   （1）wctype.h的实现更通用，它定义一个描述宽字符属性的类型wctype_t，为unsigned long标量类型，实现了可扩展的、特定区域设置的宽字符分类功能。同样它也把所有属性类封装在一个enum中，每个属性对应一个枚举常量。wctype函数用来构造一个字符属性，参数为标识这个属性的字符串，主要有"alnum"、"alpha"、 "cntrl"、"digit"、"graph"、"lower"、"print"等，对应iswxxx属性分类函数。iswctype函数测试宽字符WC是否属于DESC属性类。调用iswctype时LC_CTYPE类别的设置应与wctype构造desc值时的LC_CTYPE设置相同。
   （2）宽字符集的分类取决于区域设置，其标准属性类映射到ASCII中的关系要理清楚：
   字母或数字 = 字母 || 数字
   大(小)写字母 = !控制字符 && !数字 && !标点符号 && !空白字符
   字母 = (大写字母 || 小写字母) && !控制字符 && !数字 && !标点符号 && !空白字符  
   图形字符 = 可打印字符 && !空格
   标点符号 = 可打印字符 && !字母 && !数字 && !空白字符
   空白字符 = !字母 && !数字 && !图形字符 && !标点符号
   （3）对字符属性的转换，wctype.h也定义了一个描述宽字符转换的类型wctrans_t，为32位整型指针。wctrans函数用来构造一个字符转换，参数为标识这个转换的字符串，主要有"tolower"、"toupper"，对应towxxx转换函数，这个转换针对当前区域设置的LC_CTYPE类别值。towctrans函数使用DESC所示的转换来对宽字符WC进行转换。
   （4）在函数实现文件wcfuncs.c中，同样用了一个宏func(name, type)来简化实现。实现代码主要用到了_NL_CURRENT_WORD宏、LC_CTYPE类别宏、NL_CTYPE_MAP_OFFSET偏移宏。这些宏的功能在编译器内部或其附带的库中实现了。wctrans_table_lookup函数在wchar-lookup.h中定义，用于查询映射表，以获得转换后的宽字符。映射表有点类似于Unix的文件结构，用32位的字作为下标索引。宽字符集的每个字符被切割成4个比特块存储在位表的前面表项中，后面的几个表项存放了一级子表、二级子表、以及三级子表的指针。

C标准库源码解读(VC9.0版本)——ctype.h
行者无疆的专栏
02-04 5726
ANSI C文档（C89 http://flash-gordon.me.uk/ansi.c.txt）如是说： 4.3 CHARACTER HANDLING    The header declares several functions useful for testingand mapping characters./89/ In all cases the argument is an
C语言知识：C标准库函数深度解读（一）
weixin_56154577的博客
04-01 1409
C标准库是C语言的核心组成部分之一，为C程序提供了大量预定义的函数、数据类型、宏和常量，极大地扩展了C语言的功能，简化了常见任务的实现。
C标准库源码解剖(3)：字符处理函数ctype.h和wctype.h
Jack Zhou的专栏
10-05 7238
    字符处理包括分类（即属性判断）和转换函数。ASCII字符主要可分类为控制字符、空白字符、可打印字符、数字字符、字母字符（大写和小写）、标点符号等。    1、ctype.h：标准的属性判断函数有isalnum,isalpha,iscntrl,isdigit,isxdigit,isgraph,isprint,ispunct,islower,isupper,isspace, isbla
C标准库源码解剖(3)：字符处理函数ctype.h和wctype.h.pdf
11-20
《C标准库源码解剖(3)：字符处理函数ctype.h和wctype.h》 在C编程语言中，字符处理是程序设计中常见的任务之一，涉及到字符的分类和转换。ctype.h和wctype.h是C标准库中的两个头文件，它们提供了用于处理ASCII字符...
ctype.h这个头文件包含的函数
最新发布
03-21
它们通常位于 `<wctype.h>` 头文件中，但与 `<ctype.h>` 的逻辑相似。 --- ### 示例代码展示 以下是一个简单示例，演示如何使用部分 `<ctype.h>` 提供的功能来验证字符串的内容特性： ```c #include <stdio.h> #...
CC++程序设计语言之常用头文件及函数汇总.docx
10-26
* `wctype.h`：提供了宽字符分类和转换函数，如 `iswalpha()`、`iswdigit()`、`towlower()` 等。 数学运算 * `math.h`：提供了数学函数，如 `sin()`、`cos()`、`tan()` 等。 * `float.h`：提供了浮点数处理函数，...
CC++程序设计语言之常用头文件及函数汇总.pdf
10-26
18. `<wctype.h>`：宽字符分类函数，如`iswalpha()`。 ### C++ 标准库头文件 1. `<algorithm>`：STL中的通用算法，如排序、查找、交换等。 2. `<bitset>`：STL位集容器，用于存储位集合。 3. `<cctype>`：与C的`...
C/C++基础头文件与常用函数详解：可变参数和stdio.h
18. **wctype.h**：宽字符分类函数，用于识别字符类别。 接着，我们看传统的C++头文件： 19. **fstream.h**：在C++中，已经过时，应改用`<fstream>`处理文件流。 20. **iomanip.h**：同样，应使用`<iomanip>`来...
STL（C++标准库，体系结构及其内核分析）（STL源码剖析）（更新完毕）
世界仙境与冷酷尽头's Blog
09-03 7487
STL（C++标准库，体系结构及其内核分析）（STL源码剖析）（更新完毕）
C/C++笔试必须熟悉掌握的头文件系列（七）——cctype/ctype.h
无鞋童鞋的博客
10-31 1207
c++中”cctype”，c中应该是“ctype.h”，没有必要过多说明，都是对单个字符判断其类型的函数。 以下为字符函数库中常用的函数： 　isalnum() 如果参数是字母数字，即字母或数字，该函数返回true 　isalpha() 如果参数是字母，该函数返回真 　isblank() 如果参数是空格或水平制表符，该函数返回true 　iscntrl() 如果参数是
c语言函数库----＜ctype.h＞
qq_61884165的博客
12-02 3106
<ctype.h>是c标准函数库中的头文件，定义了一批c语言字符分类函数，下面将介绍<ctype.h>中的一些函数。 1、isascii()函数 isascii()函数是c语言中字符检测函数。通常用于检查参数c是否为ASCII 码字符，也就是判断c 的范围是否在0 到127 之间。若参数c 为ASCII 码字符, 则返回TRUE（非0）, 否则返回NULL(0)。 #include<stdio.h> #include<ctype.h> int main
ctype.h中函数
goingyou的专栏
04-19 555
分类函数,所在函数库为ctype.hint isalpha(int ch)  若ch是字母(A-Z,a-z)返回非0值,否则返回0int isalnum(int ch)  若ch是字母(A-Z,a-z)或数字(0-9)                     返回非0值,否则返回0int isascii(int ch)  若ch是字符(ASCII码中的0-1
Turbo C 2.0 函数中文说明大全
bjxg--北极星光
08-07 1016
    Turbo C 2.0 函数中文说明大全作者：未知 来源：CnXHacker.Net 加入时间：2003-5-28 阅读次数：7685c 2.0 函数中文说明大全分类函数,所在函数库为ctype.hint isalpha(int ch) 若ch是字母(A-Z,a-z)返回非0值,否则返回0int isalnum(int ch) 若ch是字母(A-Z,a-z)
C语言ctype.h 字符处理函数
算法笨蛋
07-17 515
C语言头文件ctype.h isalnum() isalpha() isblankI() iscntrl() isdigit() isgraph() islower() isprint() ispunct() isspace() isupper() isxdigit()
C标准库头文件—ctype.h
李公子的博客
05-22 3106
·ctype.h是C标准函数库中的头文件，定义了一批C语言字符分类函数（C character classification functions），用于测试字符是否属于特定的字符类别，如字母字符、控制字符等等。既支持单字节（Byte)字符，也支持宽字符。#include&lt;ctype.h&gt;主要函数简介：①islower函数名称: islower函数原型: int islower(int ...
ctype.h函数库 ——由一道题目想到的
计算机随笔
04-21 222
题目：输入一行字符，分别统计出其中英文字母、空格、数字和其它字符的个数。   C语言里就自带有一个函数是判断是不是字母的。 分类函数,所在函数库为ctype.h int isalpha(int ch) 若ch是字母('A'-'Z','a'-'z')返回非0值,否则返回0 int isalnum(int ch) 若ch是字母('A'-'Z','a'-'z')或数字('0'-'9') 返回非0值,否...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值