字符与字符串处理函数

/*
 * 功能简介：比较两个整数的大小，返回小者
 * 参    数：a 整数1，b 整数2
 * 返 回 值：返回值较小的数字
 */
int min(int a, int b)
{
    return a > b ? b : a;
}

/*
 * 功能简介：比较两个整数的大小，返回大者
 * 参    数：a 整数1，b 整数2
 * 返 回 值：返回值较大的数字
 */
int max(int a, int b)
{
    return a > b ? a : b;
}

/*
 * 功能简介：把数字字符转成整数
 * 参    数：ch 待转换为数字的字符
 * 返 回 值：如果字符为数字字符，则返回对应数字，否则返回-1
 */
int ctoi(const char ch)
{
    if(ch >= '0' && ch <= '9') return (ch - '0');
    return -1;
}

/*
 * 功能简介：求x的y次幂
 * 参    数：x 底数，y 指数（幂）
 * 返 回 值：返回x的y次幂
 */
unsigned long _pow(const unsigned int x,unsigned const int y)
{
    int i = 0;
    int ret = 1;
    
    if(y == 0) return 1;

    for(i = 0; i < y; ++i) { ret = ret * x; }

    return ret;   
}

/*
 * 功能简介：字符串转整数，遇到非数字字符则结束循环
 * 参    数：nptr 需要转换为数字的字符串
 * 返 回 值：转换成功返回对应整数，否则返回0
 */
int _atoi(const char *nptr)
{
    int ret = 0;
    char sign = 0; // 符号标志
    int i = 0;
    const char *p = nptr;
    // 判断是否为负数字符串，即需满足第一个字符为符号，第二个字符为数字字符
    if(*nptr == '-' && (*(nptr+1) >= '0' && *(nptr+1) <= '9') ) { ++p; sign = 1; };

    for(i = 0; (*p != '\0') && (*p >= '0' && *p <= '9'); ++i) {
        ret = 10 * ret + ((*p++) - '0');
    }
    if(sign == 1 && ret != 0)
        ret = 0 - ret;

    return ret;
}

/*
 * 功能简介：字符串转长整型，遇到非数字字符则结束循环
 * 参    数：nptr 需要转换为数字的字符串
 * 返 回 值：转换成功返回对应整数，否则返回0
 */
long _atol(const char *nptr)
{
    long ret = 0;
    char sign = 0; // 符号标志
    int i = 0;
    const char *p = nptr;

    // 判断是否为负数字符串，即需满足第一个字符为符号，第二个字符为数字字符
    if(*nptr == '-' && (*(nptr+1) >= '0' && *(nptr+1) <= '9') ) { ++p; sign = 1; };

    for(i = 0; (*p != '\0') && (*p >= '0' && *p <= '9'); ++i) {
        ret = 10 * ret + ((*p++) - '0');
    }
    if(sign == 1 && ret != 0) // 取反
        ret = 0 - ret;

    return ret;
}

// 若ch是大写字母（'A'-'Z'）或（'a'-'z'）或（'0'-'9'）返回非0，否则返回0。
int _isalnum(int ch)
{
    if((ch >= '0' && ch <= '9') || 
       (ch >= 'a' && ch <= 'z') || 
       (ch >= 'A' && ch <= 'z') 
    )
        return !0;
    return 0;
}

// 若ch是'0'-'9'返回非0，否则返回0。
int _isdigit(int ch)
{
    if((ch >= '0' && ch <= '9'))
        return !0;
    return 0;
}

// 若ch是字母（'A'-'Z'）或（'a'-'z'）返回非0，否则返回0。 
int _isalpha(int ch)
{
    if((ch >= 'a' && ch <= 'z') || 
       (ch >= 'A' && ch <= 'z') 
    )
        return !0;
    return 0;
}

// 若ch是大写返回非0值，否则返回0。 
int _isupper(int ch)
{
    if(ch >= 'A' && ch <= 'Z')
        return !0;
    return 0;
}

// 若ch是小写返回非0值，否则返回0。 
int _islower(int ch)
{
    if(ch >= 'a' && ch <= 'z')
        return !0;
    return 0;
}

// 若ch是大写字母（'A'-'Z'）返回相应的小写字母（'a'-'z'）。
int _tolower(int ch)
{
    if(ch >= 'A' && ch <= 'Z')
        return ch - 'A' + 'a';
    return ch;
}

// 若ch是小写字母（'a'-'z'）返回相应的大写字母（'A'-'Z'）
int _toupper(int ch)
{
    if(ch >= 'a' && ch <= 'z')
        return ch - 'a' + 'A';
    return ch;
}

int _ctoi(const char ch)
{
    if(ch >= '0' && ch <= '9') return ch - '0';

    return -1;
}

// 取绝对值
double _fabs(const double x)
{
    if(x >= 0) return x;
    
    return 0-x;
}


// 四舍五入
double _round(const double x)
{
    long ret = 0;
    if(x >= 0) ret = x + 0.5; 
    else ret = x - 0.5;
    return ret;
} 

// 向上取整数
double _ceil(const double x)
{
    long tmp;

    if(x > 0) { 
        tmp = (long)x; 
        if(tmp != x) tmp = tmp + 1;
        return tmp;        
     }
    else { tmp = (long)x; return tmp; }
}

// 向下取整数
double _floor(const double x)
{
    long tmp;

    if(x > 0) { 
        tmp = (long)x; 
     }
    else { 
        tmp = (long)x;
        if(tmp != x) tmp = tmp - 1;
     }
     return tmp;        
}

// 把双精度val分解成整数部分和小数部分，整数部分存放在ip所指的变量中，返回小数部分
double _modf(double val,double *ip)
{
    long tmp = val;

    if(ip != NULL) (*ip) = tmp;

    return val - tmp;
}

size_t _strlen(const char *str)
{
    size_t nlen = 0;
    
    while(*str++ != '\0') ++nlen;

    return nlen;
}

char * _strcpy(char *dest, const char *src)
{
    while(*src != '\0') *dest++ = *src++;
    
    *dest = '\0';
    
    return dest;
}

char * _strncpy(char *dest, const char *src, size_t len)
{
    size_t i = 0;
    size_t src_len = _strlen(src);

    if(src_len > len) src_len = len;

    while(i < src_len)
    {
        dest[i] = src[i];
        ++i;
    }
    dest[i] = '\0';

    return dest;
}

char * _strcat(char *dest, const char *src)
{
    int dest_len = _strlen(dest);
    int i = 0;

    while(src[i] != '\0')
    {
        dest[dest_len + i] = src[i];
        ++i; 
    }
    dest[i] = '\0';
    return dest;
}

char * _strncat(char *dest, const char *src, size_t len)
{
    size_t dest_len = _strlen(dest);
    size_t src_len = _strlen(src);
    size_t i = 0;
    
    if(src_len > len) src_len = len;   
 
    while(i < src_len)
    {
        dest[dest_len + i] = src[i];
        ++i; 
    }
    dest[dest_len + i] = '\0';
    return dest;
}

char * _strchr(const char *s, const int c)
{
    size_t len = _strlen(s); 
    size_t i = 0;    

    while(i < len) { if(s[i] == c) return (char *)(&(s[i])); ++i; }

    return NULL;
}

char * _strrchr(const char *s, const int c)
{
    size_t len = _strlen(s); 
    size_t i = len - 1;    

    while(i >= 0) { if(s[i] == c) return (char *)(&(s[i])); --i; }

    return NULL;
}

int _strcmp(const char *s1, const char *s2)
{
    int i = 0;
    size_t len = 0;
    size_t s1_len = _strlen(s1);
    size_t s2_len = _strlen(s2);
    
    if(s1_len > s2_len) len = s2_len;
    else len = s1_len;

    for(i = 0; i < len; ++i)
    {
        if(s1[i] == s2[i]) continue;
        else break;       
    }

    if((i == len) && (s1_len == s2_len)) return 0;

    if(s1[i] > s2[i]) return 1;
    
    return -1; 
}

int _strncmp(const char *s1, const char *s2, const size_t n)
{
    int i = 0;
    
    for(i = 0; i < n; ++i)
    {
        if(s1[i] == s2[i]) continue;
        else break;
    }

    if(i == n) return 0;
    else if(s1[i] > s2[i]) return 1;

    return -1;
}

char * _strstr(const char *str, const char * substr)
{
    char *pos = (char *) str; // 待搜索字符串的位置。
    char *pos1 = 0;

    while (1)
    {
        if (pos[0] == 0) break;  // 如果待搜索的字符串已结束，break。

        pos1 = _strchr(pos,substr[0]);  // 在pos中查找子字符串的首字符。

        if (pos1 == 0) return 0;  // 如果没有找到，直接返回0。

        if (_strncmp(pos1, substr, _strlen(substr)) == 0) return pos1; // 如果找到了，返回找到的地址。

        pos++;  // 待搜索的位置后移一个字节。
    }

  return NULL;
}

// 安全版本的字符串拷贝函数
char * _strcpy_s(char *dest, const size_t destlen, const char *src)
{
    size_t src_len = _strlen(src);
    size_t len = destlen;
    size_t i = 0;

    if(src_len < len) len = src_len;

    memset(dest, 0, destlen);

    for(i = 0; i < len; ++i)
    {
        dest[i] = src[i];
    }
    return dest; 
}

// 安全版本的字符串拷贝函数
char * _strncpy_s(char *dest, const size_t destlen, const char *src, const size_t n)
{
    size_t len = destlen;
    size_t i = 0;

    if(n < len) len = n;

    memset(dest, 0, destlen);

    for(i = 0; i < len; ++i)
    {
        dest[i] = src[i];
    }
    return dest; 
}

// 安全版本的字符串连接函数
char * _strcat_s(char *dest, const size_t destlen, const char *src)
{
    int i = 0;
    int src_len = _strlen(src);
    int len = destlen - _strlen(dest) - 1; // 剩余可用空间
    int start = _strlen(dest); 

    memset(dest + start, 0, len);

    if(src_len < len) len = src_len;

    for(i = 0; i < len; ++i)
    {
        dest[start + i] = src[i];
    }

    return dest;
}

// 安全版本的字符串连接函数
char * _strncat_s(char *dest, const size_t destlen, const char *src, const size_t n)
{
    int i = 0;
    int len = destlen - _strlen(dest) - 1; // 剩余可用空间
    int start = _strlen(dest); 

    memset(dest + start, 0, len);

    if(n < len) len = n;

    for(i = 0; i < len; ++i)
    {
        dest[start + i] = src[i];
    }
    
   return dest;
}

// 删除字符串左边指定的字符
void delete_lchar(char *str,const char in_char)
{
    char strTemp[_strlen(str)+1];
    int iTemp=0;

    if (str == 0) return;
    if (_strlen(str) == 0) return;

    memset(strTemp,0,sizeof(strTemp));
    strcpy(strTemp,str);

    while ( strTemp[iTemp] == in_char )  iTemp++;
    memset(str,0,strlen(str)+1);
    strcpy(str,strTemp+iTemp);

    return; 
}

// 删除字符串右边指定的字符
void delete_rchar(char *str,const char in_char)
{
    size_t len = _strlen(str);
    if(str == NULL) return;
 
    while(len > 0)
    {
        if(str[--len] == in_char)
            str[len] = '\0';
        else break;
    }
}

// 删除字符串两边指定的字符
void delete_lr_char(char *str,const char in_char)
{
   delete_lchar(str, in_char); 
   delete_rchar(str, in_char); 
}

// 删除字符串中间的字符串
void delete_mid_str(char *str,const char *in_str)
{
    int i = 0;
    int nlen = 0;
    char *p = NULL;

    if(str == NULL || in_str == NULL) return;

    nlen = _strlen(in_str);

    if(_strlen(str) == 0 || nlen == 0) return; 

    p =  _strstr(str, in_str);
    
    if(p != NULL) _strcpy(p, p + nlen);
}