C++ young 程序库——y_char_function.hpp 和 y_char_traits.hpp

最新推荐文章于 2024-12-15 19:44:43 发布

原创最新推荐文章于 2024-12-15 19:44:43 发布 · 1k 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#c++ #c #library #class #delete #express

该博客展示了Young库中字符函数的C++实现，包含了如isspace、strlen等常见字符处理函数的内联定义，还定义了不同大小写比较和复制的函数，以及针对wchar_t类型的不同大小写特性类，为字符处理提供了丰富的功能。

文件位置：young/string/y_char_function.hpp

/*
The young Library
Copyright (c) 2005 by 杨桓

Permission to use, copy, modify, distribute and sell this software for any
purpose is hereby granted without fee, provided that the above copyright
notice appear in all copies and that both that copyright notice and this
permission notice appear in supporting documentation.
The author make no representations about the suitability of this software
for any purpose. It is provided "as is" without express or implied warranty.
*/

#include "../y_define.hpp"
//-----------------------------------------------------------------------------
__MACRO_CPLUSPLUS_YOUNG_LIBRARY_BEGIN_NAMESPACE__
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

inline int isspace( int c )
{
return std::isspace(c);
}

inline size_t strlen( const char* string )
{
return std::strlen(string);
}

inline int tolower( int c )
{
return std::tolower(c);
}

inline int toupper( int c )
{
return std::toupper(c);
}

inline int memcmp( const void* buf1, const void* buf2, size_t count_bytes )
{
return std::memcmp( buf1, buf2, count_bytes );
}

inline void* memcpy( void* dest, const void* src, size_t count_bytes )
{
return std::memcpy( dest, src, count_bytes );
}

inline void* memmove( void* dest, const void* src, size_t count_bytes )
{
return std::memmove( dest, src, count_bytes );
}

inline void* memset( void* dest, int c, size_t count )
{
return std::memset( dest, c, count );
}

inline const void* memchr( const void* buf, int c, size_t count )
{
return std::memchr( buf, c, count );
}

//-----------------------------------------------------------------------------

inline int iswspace( wint_t c )
{
// return std::iswspace(c);
return iswspace(c);
}

inline size_t wcslen( const wchar_t* string )
{
// return std::wcslen(string);
return wcslen(string);
}

inline int towlower( wint_t c )
{
// return std::towlower(c);
return towlower(c);
}

inline int towupper( wint_t c )
{
// return std::towupper(c);
return towupper(c);
}

inline int wmemcmp( const wchar_t* buf1, const wchar_t* buf2, size_t count )
{
// return std::wmemcmp( buf1, buf2, count );
return wmemcmp( buf1, buf2, count );
}

inline wchar_t* wmemcpy( wchar_t* dest, const wchar_t* src, size_t count )
{
// return std::wmemcpy( dest, src, count );
return wmemcpy( dest, src, count );
}

inline wchar_t* wmemmove( wchar_t* dest, const wchar_t* src, size_t count )
{
// return std::wmemmove( dest, src, count );
return wmemmove( dest, src, count );
}

inline wchar_t* wmemset( wchar_t* dest, wchar_t c, size_t count )
{
// return std::wmemset( dest, c, count );
return wmemset( dest, c, count );
}

inline const wchar_t* wmemchr( const wchar_t* buf, wchar_t c, size_t count )
{
// return std::wmemchr( buf, c, count );
return wmemchr( buf, c, count );
}

//-----------------------------------------------------------------------------

int charcmp_lower( const char* s1, const char* s2, size_t count )
{
    for( size_t i = 0; i < count; ++i,++s1,++s2 )
    {
        int value1 = tolower( *s1 );
        int value2 = tolower( *s2 );
        if( value1 != value2 )
            return ( value1 < value2 ? -1 : 1 );
    }
    return 0;
}

int charcmp_upper( const char* s1, const char* s2, size_t count )
{
    for( size_t i = 0; i < count; ++i,++s1,++s2 )
    {
        int value1 = toupper( *s1 );
        int value2 = toupper( *s2 );
        if( value1 != value2 )
            return ( value1 < value2 ? -1 : 1 );
    }
    return 0;
}

char* charcopy_lower( char* dest, const char* src, size_t count )
{
    for( size_t i = 0; i < count ; ++i,++dest,++src )
        *dest = tolower( *src );
    return dest;
}

char* charcopy_upper( char* dest, const char* src, size_t count )
{
    for( size_t i = 0; i < count ; ++i,++dest,++src )
        *dest = toupper( *src );
    return dest;
}

char* charmove_lower( char* dest, const char* src, size_t count )
{
    char* temp = new char[count];
    charcopy_lower( temp, src, count );
    memcpy( dest, temp, count );
    delete[] temp;
    return ( dest + count );
}

char* charmove_upper( char* dest, const char* src, size_t count )
{
    char* temp = new char[count];
    charcopy_upper( temp, src, count );
    memcpy( dest, temp, count );
    delete[] temp;
    return ( dest + count );
}

char* charset_lower( char* dest, char c, size_t count )
{
    char value = tolower(c);
    for( size_t i = 0; i < count; ++i,++dest )
        *dest = value;
    return dest;
}

char* charset_upper( char* dest, char c, size_t count )
{
    char value = toupper(c);
    for( size_t i = 0; i < count; ++i,++dest )
        *dest = value;
    return dest;
}

//-----------------------------------------------------------------------------

int wcharcmp_lower( const wchar_t* s1, const wchar_t* s2, size_t count )
{
    for( size_t i = 0; i < count; ++i,++s1,++s2 )
    {
        int value1 = towlower( *s1 );
        int value2 = towlower( *s2 );
        if( value1 != value2 )
            return ( value1 < value2 ? -1 : 1 );
    }
    return 0;
}

int wcharcmp_upper( const wchar_t* s1, const wchar_t* s2, size_t count )
{
    for( size_t i = 0; i < count; ++i,++s1,++s2 )
    {
        int value1 = towupper( *s1 );
        int value2 = towupper( *s2 );
        if( value1 != value2 )
            return ( value1 < value2 ? -1 : 1 );
    }
    return 0;
}

wchar_t* wcharcopy_lower( wchar_t* dest, const wchar_t* src, size_t count )
{
    for( size_t i = 0; i < count ; ++i,++dest,++src )
        *dest = towlower( *src );
    return dest;
}

wchar_t* wcharcopy_upper( wchar_t* dest, const wchar_t* src, size_t count )
{
    for( size_t i = 0; i < count ; ++i,++dest,++src )
        *dest = towupper( *src );
    return dest;
}

wchar_t* wcharmove_lower( wchar_t* dest, const wchar_t* src, size_t count )
{
    wchar_t* temp = new wchar_t[count];
    wcharcopy_lower( temp, src, count );
    memcpy( dest, temp, sizeof(wchar_t) * count );
    delete[] temp;
    return ( dest + count );
}

wchar_t* wcharmove_upper( wchar_t* dest, const wchar_t* src, size_t count )
{
    wchar_t* temp = new wchar_t[count];
    wcharcopy_upper( temp, src, count );
    memcpy( dest, temp, sizeof(wchar_t) * count );
    delete[] temp;
    return ( dest + count );
}

wchar_t* wcharset_lower( wchar_t* dest, wchar_t c, size_t count )
{
    int value = towlower(c);
    for( size_t i = 0; i < count; ++i,++dest )
        *dest = value;
    return dest;
}

wchar_t* wcharset_upper( wchar_t* dest, wchar_t c, size_t count )
{
    int value = towupper(c);
    for( size_t i = 0; i < count; ++i,++dest )
        *dest = value;
    return dest;
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
__MACRO_CPLUSPLUS_YOUNG_LIBRARY_END_NAMESPACE__
#endif
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

文件位置：young/y_char_traits.hpp

/*
The young Library
Copyright (c) 2005 by 杨桓

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
#ifndef __MACRO_CPLUSPLUS_YOUNG_LIBRARY_CHAR_TRAITS_HEADER_FILE__
#define __MACRO_CPLUSPLUS_YOUNG_LIBRARY_CHAR_TRAITS_HEADER_FILE__
//-----------------------------------------------------------------------------
#include "string/y_char_function.hpp"
//-----------------------------------------------------------------------------
__MACRO_CPLUSPLUS_YOUNG_LIBRARY_BEGIN_NAMESPACE__
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

typedef std::mbstate_t mbstate_t;
typedef std::streampos streampos;
typedef std::streamoff streamoff;
typedef std::streampos wstreampos;
typedef std::streamoff wstreamoff;
//typedef std::wstreampos wstreampos;
//typedef std::wstreamoff wstreamoff;

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

template< typename CharType >
class char_traits
{
public:
    typedef CharType    char_type;
    typedef long        int_type;
    typedef streampos   pos_type;
    typedef streamoff   off_type;
    typedef mbstate_t   state_type;
    typedef def_size_t size_type;

static char_type eos() { return char_type(); }
static bool is_del( char_type c ) { return false; }

    static void assign( char_type& d, const char_type& s )
        { d = s; }
    static bool eq( const char_type& c1, const char_type& c2 )
        { return ( c1 == c2 ); }
    static bool lt( const char_type& c1, const char_type& c2 )
        { return ( c1 < c2 ); }

    static char_type to_char_type( const int_type& i )
        { return static_cast<char_type>( i ); }
    static int_type to_int_type( const char_type& c )
        { return static_cast<int_type>( c ); }
    static bool eq_int_type( const int_type& i1, const int_type& i2 )
        { return ( i1 == i2 ); }

    static int_type eof()
        { return static_cast<int_type>( EOF ); }
    static int_type not_eof( const int_type& i )
        { return ( i == eof() ? 0 : i ); }

    static size_type length( const char_type* s )
    {
    size_type i = 0;
    while( !eq( *s++, eos() ) )
         ++i;
    return i;
    }

    // (1) < 0 : s1 < s2; (2) = 0 : s1 = s2; (3) > 0 : s1 > s2
    static int compare( const char_type* s1, const char_type* s2, size_type count )
    {
    for( size_type i = 0; i < count; ++i )
    {
         if( !eq( s1[i], s2[i] ) )
             return ( lt(s1[i], s2[i]) ? -1 : 1 );
    }
    return 0;
    }

    static char_type* copy( char_type* d, const char_type* s, size_type count )
    {
    for( size_type i = 0; i < count ; ++i )
         assign( d[i], s[i] );
    return ( d + count );
    }

    static char_type* move( char_type* d, const char_type* s, size_type count )
    {
    char_type* temp = new char_type[count];
    copy( temp, s, count );
    copy( d, temp, count );
    delete[] temp;
    return ( d + count );
    }

    static char_type* assign( char_type* d, size_type count, const char_type& c )
    {
    for( size_type i = 0; i < count ; ++i )
         assign( d[i], c );
    return ( d + count );
    }

    static const char_type*
    find( const char_type* buf, size_type count, const char_type& c )
    {
        for( size_type i = 0; i < count; ++i,++buf )
        {
            if( eq( *buf, c ) )
                return buf;
        }
        return NULL_POINTER;
    }

}; //end char_traits

//-----------------------------------------------------------------------------

template<>
class char_traits<char>
{
public:
    typedef char        char_type;
    typedef int         int_type;
    typedef streampos   pos_type;
    typedef streamoff   off_type;
    typedef mbstate_t   state_type;
    typedef def_size_t size_type;

static char_type eos() { return 0; }
static bool is_del( char_type c ) { return isspace(c); }

    static char_type to_char_type( const int_type& i )
        { return static_cast<char_type>( i ); }
    static int_type to_int_type( const char_type& c )
        { return static_cast<int_type>( static_cast<unsigned char>(c) ); }
    static bool eq_int_type( const int_type& i1, const int_type& i2 )
        { return ( i1 == i2 ); }

    static int_type eof()
        { return static_cast<int_type>( EOF ); }
    static int_type not_eof( const int_type& i )
        { return ( i == eof() ? 0 : i ); }

static size_type length( const char_type* s )
{ return strlen(s); }

    static int compare( const char_type* s1, const char_type* s2, size_type count )
    {
        int result = memcmp( s1, s2, count );
        if( result == 0 )
            return 0;
        else
            return ( result < 0 ? -1 : 1 );
    }

static char_type* copy( char_type* d, const char_type* s, size_type count )
{ return (char_type*)memcpy( d, s, count ); }

static char_type* move( char_type* d, const char_type* s, size_type count )
{ return (char_type*)memmove( d, s, count ); }

static char_type* assign( char_type* d, size_type count, const char_type& c )
{ return (char_type*)memset( d, c, count ); }

    static const char_type*
    find( const char_type* buf, size_type count, const char_type& c )
        { return (char_type*)memchr( buf, c, count ); }

}; //end char_traits<char>

//-----------------------------------------------------------------------------

template<>
class char_traits<wchar_t>
{
public:
    typedef wchar_t     char_type;
    typedef wint_t      int_type;
    typedef wstreamoff pos_type;
    typedef wstreampos off_type;
    typedef mbstate_t   state_type;
    typedef def_size_t size_type;

static char_type eos() { return 0; }
static bool is_del( char_type c ) { return iswspace(c); }

    static int_type eof()
        { return static_cast<int_type>( WEOF ); }
    static int_type not_eof( const int_type& i )
        { return ( i == eof() ? 0 : i ); }

static size_type length( const char_type* s )
{ return wcslen(s); }

    static int compare( const char_type* s1, const char_type* s2, size_type count )
    {
        int result = wmemcmp( s1, s2, count );
        if( result == 0 )
            return 0;
        else
            return ( result < 0 ? -1 : 1 );
    }

static char_type* copy( char_type* d, const char_type* s, size_type count )
{ return wmemcpy( d, s, count ); }

static char_type* move( char_type* d, const char_type* s, size_type count )
{ return wmemmove( d, s, count ); }

static char_type* assign( char_type* d, size_type count, const char_type& c )
{ return wmemset( d, c, count ); }

    static const char_type*
    find( const char_type* buf, size_type count, const char_type& c )
        { return wmemchr( buf, c, count ); }

}; //end char_traits<wchar_t>

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

class cmp_no_case_char_traits //比较时不区分大小写char的traits
{
public:
    typedef char        char_type;
    typedef int         int_type;
    typedef streampos   pos_type;
    typedef streamoff   off_type;
    typedef mbstate_t   state_type;
    typedef def_size_t size_type;

static char_type eos() { return 0; }
static bool is_del( char_type c ) { return isspace(c); }

    static void assign( char_type& d, const char_type& s )
        { d = s; }
    static bool eq( const char_type& c1, const char_type& c2 )
        { return ( tolower(c1) == tolower(c2) ); }
    static bool lt( const char_type& c1, const char_type& c2 )
        { return ( tolower(c1) < tolower(c2) ); }

    static char_type to_char_type( const int_type& i )
        { return static_cast<char_type>( i ); }
    static int_type to_int_type( const char_type& c )
        { return static_cast<int_type>( static_cast<unsigned char>(c) ); }
    static bool eq_int_type( const int_type& i1, const int_type& i2 )
        { return ( i1 == i2 ); }

    static int_type eof()
        { return static_cast<int_type>( EOF ); }
    static int_type not_eof( const int_type& i )
        { return ( i == eof() ? 0 : i ); }

static size_type length( const char_type* s )
{ return strlen(s); }

static int compare( const char_type* s1, const char_type* s2, size_type count )
{ return charcmp_lower( s1, s2, count ); }

static char_type* copy( char_type* d, const char_type* s, size_type count )
{ return (char_type*)memcpy( d, s, count ); }

static char_type* move( char_type* d, const char_type* s, size_type count )
{ return (char_type*)memmove( d, s, count ); }

static char_type* assign( char_type* d, size_type count, const char_type& c )
{ return (char_type*)memset( d, c, count ); }

    static const char_type*
    find( const char_type* buf, size_type count, const char_type& c )
        { return (char_type*)memchr( buf, c, count ); }

}; //end cmp_no_case_char_traits

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

class lower_char_traits //全部是小写char的traits
{
public:
    typedef char        char_type;
    typedef int         int_type;
    typedef streampos   pos_type;
    typedef streamoff   off_type;
    typedef mbstate_t   state_type;
    typedef def_size_t size_type;

static char_type eos() { return 0; }
static bool is_del( char_type c ) { return isspace(c); }

    static void assign( char_type& d, const char_type& s )
        { d = tolower(s); }
    static bool eq( const char_type& c1, const char_type& c2 )
        { return ( c1 == c2 ); }
    static bool lt( const char_type& c1, const char_type& c2 )
        { return ( c1 < c2 ); }

    static char_type to_char_type( const int_type& i )
        { return static_cast<char_type>( i ); }
    static int_type to_int_type( const char_type& c )
        { return static_cast<int_type>( static_cast<unsigned char>(c) ); }
    static bool eq_int_type( const int_type& i1, const int_type& i2 )
        { return ( i1 == i2 ); }

    static int_type eof()
        { return static_cast<int_type>( EOF ); }
    static int_type not_eof( const int_type& i )
        { return ( i == eof() ? 0 : i ); }

static size_type length( const char_type* s )
{ return strlen(s); }

static char_type* copy( char_type* d, const char_type* s, size_type count )
{ return charcopy_lower( d, s, count ); }

static char_type* move( char_type* d, const char_type* s, size_type count )
{ return charmove_lower( d, s, count ); }

static char_type* assign( char_type* d, size_type count, const char_type& c )
{ return charset_lower( d, c, count ); }

    static const char_type*
    find( const char_type* buf, size_type count, const char_type& c )
        { return (char_type*)memchr( buf, c, count ); }

}; //end lower_char_traits

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

class upper_char_traits //全部是大写char的traits
{
public:
    typedef char        char_type;
    typedef int         int_type;
    typedef streampos   pos_type;
    typedef streamoff   off_type;
    typedef mbstate_t   state_type;
    typedef def_size_t size_type;

static char_type eos() { return 0; }
static bool is_del( char_type c ) { return isspace(c); }

    static void assign( char_type& d, const char_type& s )
        { d = toupper(s); }
    static bool eq( const char_type& c1, const char_type& c2 )
        { return ( c1 == c2 ); }
    static bool lt( const char_type& c1, const char_type& c2 )
        { return ( c1 < c2 ); }

    static char_type to_char_type( const int_type& i )
        { return static_cast<char_type>( i ); }
    static int_type to_int_type( const char_type& c )
        { return static_cast<int_type>( static_cast<unsigned char>(c) ); }
    static bool eq_int_type( const int_type& i1, const int_type& i2 )
        { return ( i1 == i2 ); }

    static int_type eof()
        { return static_cast<int_type>( EOF ); }
    static int_type not_eof( const int_type& i )
        { return ( i == eof() ? 0 : i ); }

static size_type length( const char_type* s )
{ return strlen(s); }

static char_type* copy( char_type* d, const char_type* s, size_type count )
{ return charcopy_upper( d, s, count ); }

static char_type* move( char_type* d, const char_type* s, size_type count )
{ return charmove_upper( d, s, count ); }

static char_type* assign( char_type* d, size_type count, const char_type& c )
{ return charset_upper( d, c, count ); }

    static const char_type*
    find( const char_type* buf, size_type count, const char_type& c )
        { return (char_type*)memchr( buf, c, count ); }

}; //end upper_char_traits

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

//字符串内全部是小写char并且和其他字符串进行比较时不区分大小写的traits
class cmp_no_case_lower_char_traits
{
public:
    typedef char        char_type;
    typedef int         int_type;
    typedef streampos   pos_type;
    typedef streamoff   off_type;
    typedef mbstate_t   state_type;
    typedef def_size_t size_type;

static char_type eos() { return 0; }
static bool is_del( char_type c ) { return isspace(c); }

    static void assign( char_type& d, const char_type& s )
        { d = tolower(s); }
    static bool eq( const char_type& c1, const char_type& c2 )
        { return ( tolower(c1) == tolower(c2) ); }
    static bool lt( const char_type& c1, const char_type& c2 )
        { return ( tolower(c1) < tolower(c2) ); }