c++ char_traits模板类的实现！！！

本人写过与此相关的两篇博客，一个是<cstring>头文件的实现，还有一个是<cwchar>的实现。这里的char_traits模板类在此基础上实现。

为了方便。将源码一起封装于名字空间mystd里。

代码例如以下！！！

// 此文件命名为   "char_traits.h"

// vs2012 调试通过
#pragma once
#ifndef MYSTD_CHAR_TRAITS_H
#define MYSTD_CHAR_TRAITS_H

#include<cstddef> // std::size_t
#include<cassert>

#pragma push_macro("EOF")
#undef EOF
#define EOF (-1)

#pragma push_macro("WEOF")
#undef WEOF
#define WEOF (unsigned short)(0xFFFF)

#define MYSTD_BEGIN namespace mystd{
#define MYSTD_END  }

#ifdef __cplusplus

MYSTD_BEGIN  //cstring.h
typedef std::size_t size_type;
typedef unsigned char UCHAR;
// C语言版本号，void * memchr(const void *,int,size_type);
inline const void* memchr(const void *pointer,int val, size_type num)
{
assert(pointer != 0);
UCHAR *ptr = (UCHAR*)pointer;
for(size_type i = 0; i < num; ++i)
{
if(*ptr == val)
break;
++ptr;
}
return ptr;
}
inline void* memchr(void *pointer, int val,size_type num) //c++重载
{
assert(pointer != 0);
return (void*)mystd::memchr((const void*)pointer,val,num); // 转调
}
inline size_type strlen(const char *str)
{
assert(str != 0);
size_type count = 0;
while(*str++)
++count;
return count;
}

inline void* memmove(void *destination,const void *source, size_type num)
{ // 对于memmove函数的实现，c++之父在《c++ 程序设计语言》（十周年中文纪念版第16章开篇）
//就说过，此函数无法由c++语言本身达到最优实现，实际应用时还是用标准库吧！
assert(destination != 0 && source != 0);
if(destination == source || num == 0)
return destination;
UCHAR *des = (UCHAR*)destination;
const UCHAR *src = (UCHAR*)source;
if(des < src || des >= src + num)
{
while(num--)
*des++ = *src++;
return destination;
}
des += num;
src += num;
while(num--) // 倒序复制
*--des = *--src;
return destination;
}
inline void* memcpy(void *destination,const void *source, size_type num)
{
assert(destination != 0 && source != 0);
return mystd::memmove(destination,source,num);
}
inline int memcmp(const void *pointer_1,const void *pointer_2,size_type num)
{
assert(pointer_1 != 0 && pointer_2 != 0);
const UCHAR *ptr_1 = (UCHAR*)pointer_1;
const UCHAR *ptr_2 = (UCHAR*)pointer_2;
while(num-- && *ptr_1 == *ptr_2)
++ptr_1,++ptr_2;
if(num == size_type(-1))
return 0;
else
return *ptr_1 - *ptr_2;
}
inline void* memset(void *pointer,int val,size_type num)
{
assert(pointer != 0);
UCHAR *ptr = (UCHAR*)pointer;
while(num--)
*ptr++ = val;
return pointer;
}
inline char* strcat(char *destination,const char *source)
{
assert(destination != 0 && source != 0);
char *ptr = destination + mystd::strlen(destination);
while(*ptr++ = *source++);
return destination;
}
inline char *strncat(char *destination,const char *source,size_type num)
{
assert(destination != 0 && source != 0);
char *ptr = destination + mystd::strlen(destination);
while(num-- && *source)
*ptr++ = *source++;
*ptr = 0;   // null-character 复制
return destination;
}
inline char *strcpy(char *destination,const char *source)
{
assert(destination != 0 && source != 0);
char *des = destination;
while(*des++ = *source++);
return destination; // null-character被复制
}
inline char *strncpy(char *destination,const char *source,size_type num)
{
assert(destination != 0 && source != 0);
char *des = destination;
while(num--)
*des++ = *source++;
return destination; // null-character可能没有被复制
}
inline int strcmp(const char *str1,const char *str2)
{
assert(str1 != 0 && str2 != 0);
while(*str1 && *str1 == *str2)
++str1, ++str2;
return *str1 - *str2;
}
inline int strncmp(const char *str1,const char *str2,size_type num)
{
assert(str1 != 0 && str2 != 0);
while(num-- && *str1 && *str1 == *str2)
++str1, ++str2;
if(num == size_type(-1))  // 包括了num == 0的情况
return 0;
else
return *str1 - *str2;
}
//C语言仅仅有一个版本号 char* strchr(const char *, int);
inline const char* strchr(const char *str,int character)
{
assert(str != 0);
// 语言标准规定character 为int,这里转换一下
const char chr = *(char*)&character;
while(*str && *str != chr)
++str;
if(*str)
return str;
else
return 0;
}
inline char* strchr(char *str,int character) //c++重载
{
assert(str != 0);
return (char*)mystd::strchr((const char*)str,character);
}
inline const char* strrchr(const char *str,int character)
{ //这里的character 可能包括null-character
assert(str != 0);
// 语言标准规定character 为int,这里转换一下
const char chr = *(char*)&character;
size_type len = mystd::strlen(str);
const char *ptr = str + len;
if(chr == 0)
return ptr;
--ptr;
while(len--)
if(*ptr == chr)
return ptr;
else
--ptr;
return 0;  //无匹配的字符
}
inline char* strrchr(char *str,int character)
{
assert(str != 0);
return (char*)mystd::strrchr((const char*)str,character); // 转调
}
//c语言版本号char* strstr(const char *,const char*);
inline const char* strstr(const char* str1,const char* str2)
{
assert(str1 != 0 && str2 != 0);
size_type len_1 = mystd::strlen(str1);
size_type len_2 = mystd::strlen(str2);
if(len_1 < len_2)
return 0;
const char *search_last = str1 + (len_1 - len_2);
while(str1 <= search_last)
{
if(mystd::strncmp(str1,str2,len_2) == 0)
return str1;
else
++str1;
}
return 0;
}
inline char* strstr(char *str1,const char *str2) //c++重载
{
assert(str1 != 0 && str2 != 0);
return (char*)mystd::strstr((const char*)str1,str2);
}
inline bool is_inside(const char *str,char chr) // 辅助函数，内部使用
{
assert(str != 0);
while(*str)
{
if(*str == chr)
return true;
else
++str;
}
return false;
}
inline size_type strspn(const char* str1,const char *str2)
{
assert(str1 != 0 && str2 != 0);
size_type count = 0;
while(*str1 && is_inside(str2,*str1))
++count, ++str1;
return count;
}
inline size_type strcspn(const char* str1,const char *str2)
{
assert(str1 != 0 && str2 != 0);
size_type count = 0;
while(*str1 && !is_inside(str2,*str1))
++count, ++str1;
return count;
}
// c语言版本号char* strpbrk(const char *,const char *);
inline const char* strpbrk(const char *str1,const char *str2)
{
assert(str1 != 0 && str2 != 0);
while(*str1 && !is_inside(str2,*str1))
++str1;
if(*str1 == 0)
return 0;
else
return str1;
}
inline char* strpbrk(char *str1,const char *str2) //c++重载
{
assert(str1 != 0 && str2 != 0);
return (char*)strpbrk((const char*)str1,str2);  //转调
}
inline char* strtok(char *str,const char *delim)
{
#ifdef _DEBUG
static bool first_switch = false;
if(!first_switch)
assert(str != 0);
assert(delim != 0);
#endif
static char * p_location = 0;  //记录搜索起始位置
if(str)
p_location = str;
char *ptr = mystd::strpbrk(p_location,delim);
char *temp = p_location;
if(ptr == 0) // 找不到分隔符,默觉得搜索结束
{
#ifdef _DEBUG
first_switch = false;  // 搜索结束。first_switch置为false
#endif
p_location = 0;  // 搜索结束。p_location 复位
return temp;
}
#ifdef _DEBUG
first_switch = true;
#endif
*ptr = 0;
p_location = ptr + 1; // 位置更新
return temp;
}
inline size_type strxfrm(char *destination,const char *source,size_type num);
inline int strcoll(const char *str1,const char *str2);
inline char* strerror(int errnum);

MYSTD_END  // end of namespace mystd

MYSTD_BEGIN   //宽字符版本号
typedef std::size_t size_type;
typedef wchar_t char_type;
inline size_type wcslen(const char_type* wcs)
{
assert(wcs != 0);
size_type count = 0;
while(*wcs++)
++count;
return count;
}
inline char_type* wcscat(char_type* destination,const char_type *source)
{
assert(destination != 0 && source != 0);
char_type *des = destination + mystd::wcslen(destination);
while(*des++ = *source++);
return destination;
}
inline char_type* wcsncat(char_type* destination,const char_type *source,size_type num)
{
assert(destination != 0 && source != 0);
char_type *des = destination + mystd::wcslen(destination);
while(num-- && *source)
*des++ = *source++;
*des = 0;
return destination;
}
inline char_type* wcscpy(char_type *destination,const char_type *source)
{
assert(destination != 0 && source != 0);
char_type *des = destination;
while(*des++ = *source++);
return destination;
}
inline char_type* wcsncpy(char_type *destination,const char_type *source,size_type num)
{
assert(destination != 0 && source != 0);
char_type *des = destination;
while(num--)
*des++ = *source++;
return destination; // 可能不包括null wide character
}
inline int wcscmp(const char_type *wcs1,const char_type *wcs2)
{
assert(wcs1 != 0 && wcs2 != 0);
while(*wcs1 && *wcs1 == *wcs2)
++wcs1, ++wcs2;
return *wcs1 - *wcs2;
}
inline int wcsncmp(const char_type *wcs1,const char_type *wcs2,size_type num)
{
assert(wcs1 != 0 && wcs2 != 0);
while(num-- && *wcs1 && *wcs1 == *wcs2)
++wcs1, ++wcs2;
if(num == size_type(-1))  // 包括了num == 0的情况
return 0;
else
return *wcs1 - *wcs2;
}
inline const char_type* wmemchr(const char_type* pointer,char_type val,size_type num)
{
assert(pointer != 0);
char_type *ptr = (char_type*)pointer;
for(size_type i = 0; i < num; ++i)
{
if(*ptr == val)
break;
++ptr;
}
return ptr;
}
inline char_type* wmemchr(char_type* pointer,char_type val,size_type num)
{
assert(pointer != 0);
return (char_type*)wmemchr((const char_type*)pointer,val,num);
}
inline int wmemcmp(const char_type *ptr_1,const char_type *ptr_2,size_type num)
{
assert(ptr_1 != 0 && ptr_2 != 0);
while(num-- && *ptr_1 == *ptr_2)
++ptr_1, ++ptr_2;
if(num == size_type(-1))
return 0;
else
return *ptr_1 - *ptr_2;
}
inline char_type* wmemset(char_type *pointer,char_type val,size_type num)
{
assert(pointer != 0);
char_type *ptr = pointer;
while(num--)
*ptr++ = val;
return pointer;
}
inline char_type* wmemmove(char_type *destination,const char_type *source,size_type num)
{
assert(destination != 0 && source != 0);
if(destination == source || num == 0)
return destination;
char_type *des = (char_type*)destination;
const char_type *src = (char_type*)source;
if(des < src || des >= src + num)
{
while(num--)
*des++ = *src++;
return destination;
}
des += num;
src += num;
while(num--) // 倒序复制
*--des = *--src;
return destination;
}
inline char_type* wmemcpy(char_type *destination,const char_type *source,size_type num)
{
assert(destination != 0 && source != 0);
return mystd::wmemmove(destination,source,num);
}
inline bool w_is_inside(const char_type *wcs,char_type val) // 辅助函数。内部使用
{
assert(wcs != 0);
while(*wcs)
{
if(*wcs == val)
return true;
else
++wcs;
}
return false;
}
inline size_type wcsspn(const char_type *wcs1,const char_type *wcs2)
{
assert(wcs1 != 0 && wcs2 != 0);
size_type count = 0;
while(*wcs1 && w_is_inside(wcs2,*wcs1))
++count, ++wcs1;
return count;
}
inline size_type wcscspn(const char_type *wcs1,const char_type *wcs2)
{
assert(wcs1 != 0 && wcs2 != 0);
size_type count = 0;
while(*wcs1 && !w_is_inside(wcs2,*wcs1))
++count, ++wcs1;
return count;
}
inline const char_type* wcsstr(const char_type *wcs1,const char_type *wcs2)
{
assert(wcs1 != 0 && wcs2 != 0);
size_type len_1 = mystd::wcslen(wcs1);
size_type len_2 = mystd::wcslen(wcs2);
if(len_1 < len_2)
return 0;
const char_type *search_last = wcs1 + (len_1 - len_2);
while(wcs1 <= search_last)
{
if(mystd::wcsncmp(wcs1,wcs2,len_2) == 0)
return wcs1;
else
++wcs1;
}
return 0;
}
inline char_type* wcsstr(char_type *wcs1,const char_type *wcs2)
{
assert(wcs1 != 0 && wcs2 != 0);
return (char_type*)mystd::wcsstr((const char_type*)wcs1,wcs2);
}

inline const char_type* wcschr(const char_type *wcs,char_type val)
{
assert(wcs != 0);
while(*wcs && *wcs != val)
++wcs;
if(*wcs)
return wcs;
else
return 0;
}
inline char_type* wcschr(char_type *wcs,char_type val)
{
assert(wcs != 0);
return (char_type*)mystd::wcschr((const char_type*)wcs,val);
}
inline const char_type* wcsrchr(const char_type *wcs,char_type val)
{ // val可能为null wide character
assert(wcs != 0);
size_type len = mystd::wcslen(wcs);
const char_type *ptr = wcs + len;
if(val == 0)
return ptr;
--ptr;
while(len--)
if(*ptr == val)
return ptr;
else
--ptr;
return 0;  //无匹配的字符
}
inline char_type* wcsrchr(char_type *wcs,char_type val)
{  //val可能为null wide character
assert(wcs != 0);
return (char_type*)mystd::wcsrchr((const char_type*)wcs,val); // 转调
}

inline const char_type* wcspbrk(const char_type *wcs1,const char_type *wcs2)
{
assert(wcs1 != 0 && wcs2 != 0);
while(*wcs1 && !w_is_inside(wcs2,*wcs1))
++wcs1;
if(*wcs1 == 0)
return 0;
else
return wcs1;
}
inline char_type* wcspbrk(char_type *wcs1,const char_type *wcs2)
{
assert(wcs1 != 0 && wcs2 != 0);
return (char_type*)mystd::wcspbrk((const char_type*)wcs1,wcs2);
}
inline char_type* wcstok(char_type *wcs,const char_type *delim)
{
#ifdef _DEBUG
static bool first_switch = false;
if(!first_switch)
assert(wcs != 0);
assert(delim != 0);
#endif
static char_type * p_location = 0;  //记录搜索起始位置
if(wcs)
p_location = wcs;
char_type *ptr = mystd::wcspbrk(p_location,delim);
char_type *temp = p_location;
if(ptr == 0) // 找不到分隔符,默觉得搜索结束
{
#ifdef _DEBUG
first_switch = false;  // 搜索结束，first_switch置为false
#endif
p_location = 0;  // 搜索结束，p_location 复位
return temp;
}
#ifdef _DEBUG
first_switch = true;
#endif
*ptr = 0;
p_location = ptr + 1; // 位置更新
return temp;
}
inline size_type wcsxfrm(char_type *destination,const char_type *source,size_type num);

MYSTD_END

MYSTD_BEGIN
typedef unsigned short wint_t;
template<class charT>
struct char_traits{
typedef std::size_t size_type;
};

template<>  // char特化
struct char_traits<char>{
typedef int int_type;
typedef char char_type;
public:
static size_type length(const char_type *str) throw()
{
assert(str != 0);
return mystd::strlen(str);
}

static void assign(char_type& chr,const char_type& val) throw()
{
chr = val;
}
static char_type assign(char_type *ptr,size_type num,char_type chr) throw()
{
assert(ptr != 0);
mystd::memset(ptr,chr,num);
return chr;
}
static int compare(const char_type *str1,const char_type *str2,size_type num) throw()
{
assert(str1 != 0 && str2 != 0);
return mystd::strncmp(str1,str2,num); // 注意C风格字符串
}
static char_type* move(char_type *des,const char_type *src,size_type num) throw()
{
assert(des != 0 && src != 0);
#ifdef _DEBUG
return (char_type*)mystd::memmove(des,src,num);
#else
return (char_type*)std::memmove(des,src,num); // 标准库版本号效率更高
#endif
}
static char_type* copy(char_type *des,const char_type *src,size_type num) throw()
{
assert(des != 0 && src != 0);
#ifdef _DEBUG
return (char_type*)mystd::memcpy(des,src,num);
#else
return (char_type*)std::memcpy(des,src,num); // 标准库版本号效率更高
#endif
}
static bool eq(const char_type& chr_1,const char_type& chr_2)
{
return chr_1 == chr_2;
}
static const char_type* find(const char_type* ptr,size_t num,const char_type& chr)
{
assert(ptr != 0);
while(num-- && *ptr != chr)
++ptr;
if(*ptr == chr && num != size_type(-1)) // 不依赖于null character
return ptr;
else
return 0;
}
static char_type to_char_type(const int_type& chr) throw()
{
assert(chr < 0xFF);
return *(char_type*)&chr;
}
static int_type to_int_type(const char_type& chr) throw()
{
return static_cast<char_type>(chr);
}
static int_type eof() throw()
{
return EOF;
}
};

template<>  // 宽字符版本号
struct char_traits<wchar_t>{
typedef wint_t int_type;
typedef wchar_t char_type;
public:
static size_type length(const char_type *wcs) throw()
{
return mystd::wcslen(wcs);
}
static void assign(char_type& wc,const char_type& val) throw()
{
wc = val;
}
static char_type assign(char_type *ptr,size_type num,char_type wc) throw()
{
assert(ptr != 0);
while(num--)
*ptr++ = wc;
return wc;
}
static int compare(const char_type *wcs1,const char_type *wcs2,size_type num) throw()
{
assert(wcs1 != 0 && wcs2 != 0);
return mystd::wcsncmp(wcs1,wcs2,num);
}
static char_type* move(char_type *des,const char_type *src,size_type num) throw()
{
assert(des != 0 && src != 0);
#ifdef _DEBUG
return (char_type*)mystd::wmemmove(des,src,num);
#else
return (char_type*)std::wmemmove(des,src,num);  // 标准库版本号效率更高
#endif
}
static char_type* copy(char_type *des,const char_type *src,size_type num) throw()
{
assert(des != 0 && src != 0);
#ifdef _DEBUG
return (char_type*)mystd::wmemcpy(des,src,num);
#else
return (char_type*)std::wmemcpy(des,src,num);  // 标准库版本号效率更高
#endif
}
static bool eq(const char_type& wc_1,const char_type& wc_2)
{
return wc_1 == wc_2;
}
static const char_type* find(const char_type* ptr,size_t num,const char_type& wc)
{
assert(ptr != 0);
while(*ptr && num-- && *ptr != wc)
++ptr;
if(*ptr == wc)
return ptr;
else
return 0;
}
static char_type to_char_type(const int_type& wc) throw()
{
assert(wc < 0xFFFF);
return wc;
}
static int_type to_int_type(const char_type& wc) throw()
{
assert(wc < 0xFFFF);
return wc;
}
static int_type eof() throw()
{
return WEOF;
}
};

MYSTD_END // end of namespace mystd
#endif // __cplusplus
#pragma pop_macro("WEOF")
#pragma pop_macro("EOF")
#endif // MYSTD_CHAR_TRAITS_H

希望高手批评指正。！！