字符串

 

#include <stdio.h>

#include <ctype.h>

//字符操作的函数

//int     isalnum(int);

//int     isalpha(int);

//int     isdigit(int);

//int     isgraph(int);

//int     islower(int);

//int     ispunct(int);

//int     isspace(int);//判断是否为空格

//int     isupper(int);

//int     isxdigit(int);

//int     tolower(int);

//int     toupper(int);

//int     digittoint(int);

//int     ishexnumber(int);

//int     isnumber(int);

//int main(int argc, const char * argv[]) {

//    

//    printf("isalnum = %d ", isalnum('a'));//判断是否为数字字符或者英文字母

//    printf("isalpha = %d ", isalpha('*'));//判断是否为英文字母

//    printf("isdigit = %d ", isdigit('&'));//判断是否为数字字符

//    printf("isgraph = %d ", isgraph(' '));//判断是否为可见字符

//    printf("islower = %d ", islower('*'));//判断是否为小写字母

//    printf("ispunct = %d ", ispunct(';'));//判断是否为标点符号

//    printf("isupper = %d ", isupper('A'));//判断是否为大写字母

//    printf("isxdigit = %d ", isxdigit('a'));//判断是否为十六进制字符

//    printf("tolower = %c ", tolower('A'));//转换成小写字母

//    printf("toupper = %c ", toupper('a'));//转换成大写字母

//    printf("digittoint = %d ", digittoint('F'));//把十六进制字符转换成整型数据

//    printf("ishexnumber = %d ", ishexnumber('9'));//跟isxdigit函数相同

//    printf("isnumber = %d ", isnumber('9'));//跟isdigit函数相同

//    return 0;

//}

//字符串

//"hello world"

//1.双引号包含

//2.字符串中的每个元素占用一字节内存空间

//3.字符串末尾有隐藏字符''

//

//打印字符串用%s 跟要打印字符串的首地址相对应

//存储字符串用字符数组,或者申请的内存

//gets() //输入一个字符串

//puts() //输出一个字符串

//int main(int argc,const char *argv[])

//{

//    char str[12]="hello world";

//    printf("%s ", str);//%s打印字符串遇到''结束

//

//    char str2[100];

//    gets(str2);//遇到' '结束

//    puts(str2);

//    

//    return 0;

//}

//char str1[100]="hello world"

//char *str2="hello world";

//int main(int argc,const char *argv[])

//{

//    char str1[100]="hello world";

//    char *str2="hello world";//str2指向常量区, 常量区的内容是只读的,不可以被修改

//    

//    //*str2 = 'a';

//    str1[0]='a';

//    printf("%s ", str1);

//    return 0;

//}

//字符串长度(通常指字符串有效长度)

//"hello world"

//有效长度不包含字符串末尾的''

//sizeof strlen

//区别:

//1.sizeof 是一个运算符, strlen是一个函数

//2.sizeof 求变量或者常量占用内存空间大小, strlen 求字符串有效字符个数,操作对象是字符串

//3.sizeof 运算符是编译层次的概念, strlen函数是运行层次的概念

#include <string.h>

//size_t <==> unsigned long

//size_t my_strlen(const char *src)

//{

//    if (!src) {

//        return 0;

//    }

//    int len=0;

////    while (*src != '') {

////        len++;

////        src++;

////    }

//    for (;*src;) {

//        len++;

//        src++;

//    }

//    return len;

//}

//

//int main(int argc, char *argv[])

//{

//    char str[100]="qian feng";

//    char *pstr = str;

//    printf("%ld ", sizeof(str));

//    

//    printf("%ld ", my_strlen(str));

//    

//    printf("%ld ", sizeof(pstr));//求的是指针变量占用的内存空间大小

//    printf("%ld ", strlen(pstr));

//

//    return 0;

//}

//字符串比较函数

//int strcmp(const char *, const char *);

//int strncmp(const char *, const char *, size_t);

//size_t : 限制最大比较字符个数

//返回值 大于0    str1 > str2

//      等于0    str1 == str2

//      小于0    str1 < str2

//int my_strcmp(const char *str1, const char *str2)

//{

//    while (*str1==*str2 && *str1 && *str2) {

//        str1++;

//        str2++;

//    }

//    return *str1-*str2;

//}

//

//int main(int argc,const char *argv[])

//{

//    char *str1 = "abcdefgh";

//    char *str2 = "abc";

//    

//    int ret = my_strcmp(str1, str2);

//    printf("ret = %d ", ret);

//    

//    ret = strncmp(str1, str2, 7);

//    printf("ret = %d ", ret);

//

//    return 0;

//}

//字符串查找

//strchr

//char *strchr(const char *, int);

//从左往右查找字符在原字符串中第一次出现的位置,找不到返回NULL

//strrchr

//char *strrchr(const char *, int);

//倒序查找字符, 找到第一次出现的位置返回,找不到返回NULL

char *my_strchr(const char *src, char ch)

{

    while (*src) {

        if (*src==ch) {

            return (char *)src;

        }

        src++;

    }

    return NULL;

}

char *my_strrchr(const char *src, char ch)

{

    size_t len = strlen(src);

    for (long i=len; i>=0; i--) {

        if (*(src+i)==ch) {

            return (char *)(src+i);

        }

    }

    return NULL;

}

//int main(int argc,const char *argv[])

//{

//    char *str = "hello world";

//    

//    printf("%s ", my_strchr(str, 'o'));

//    

//    printf("%s ", my_strrchr(str, 'o'));

//

//

//    return 0;

//}

//字符串拷贝

//char *strcpy(char *dest, const char *src);

//dest 跟 src指向的内存不能有重叠的部分

//dest 空间足够容纳src字符串

//char *strncpy(char *dest, const char *src, size_t len);

//len 限定最多可以向dest缓冲区中拷贝的字符个数

//len = sizeof(dest)-1

char *my_strcpy(char *dest, const char *src)

{

    char *temp = dest;

    while (*src) {

        *temp = *src;

        temp++;

        src++;

    }

    *temp = '';

    return dest;

}

char *my_strncpy(char *dest ,const char *src, size_t     len)

{

    size_t i=0;

    char *temp = dest;

    while (*src && i<len) {

        *temp = *src;

        temp++;

        src++;

        i++;

    }

    if (i<len) {

        *temp = '';

    }

    return dest;

}

//int main(int argc, const char *argv[])

//{

//    char dest[100]="qianfengABCDEF";

//    char *src = "helloworld";

//    //printf("%s ", my_strcpy(dest, src));

//    //printf("%s ", dest);

//  //  printf("%s ", strcpy(dest, &dest[4]));//strcpy 操作的字符串内存不能重叠

//    

//    printf("%s ", my_strncpy(dest, src, 100-1));

//    return 0;

//}

//字符串拼接

//char *strcat(char *dest, const char *src);

//1.确定dest剩余的内存空间足够容纳src字符串

//char *strncat(char *dest, const char *src, size_t len);

//len = sizeof(dest)-strlen(dest)-1;

//len 允许最多可以拼接到dest缓冲区中的字符个数,拼接后,在新的字符串的末尾添加'';

char *my_strcat(char *dest, const char *src)

{

    size_t len = strlen(dest);

    int i=0;

    while (*src) {

        *(dest+len+i)= *src;

        src++;

        i++;

    }

    *(dest+len+i)='';

    return dest;

}

char *my_strncat(char *dest ,const char *src, size_t     len)

{

    size_t i=0;

    size_t size = strlen(dest);

    char *temp = dest+size;

    while (*src && i<len) {

        *temp = *src;

        temp++;

        src++;

        i++;

    }

    *temp = '';

    return dest;

}

//int main(int argc,const char *argv[])

//{

//    char dest[21]="hello world";

//    dest[20]='A';

//    dest[16]='W';

//    char *src = "qian feng";

//    //printf("%s ",my_strcat(dest, src));

//    

//    printf("%s ",my_strncat(dest, src,4));

//    

//    return 0;

//}

//字符串分割

//strtok

//char *strtok(char *src, const char *demi);

//int main(int argc,const char *argv[])

//{

//    char src[100]="root:qian;:feng,:jiao;yu";

//    char *ps = strtok(src, ";,:");//底层把分割符变成''

//    printf("%p %s ",ps,ps);//分割符一定用双引号包含,哪怕只有一个字符

//    printf("%p %s ",src,src);

//    

//    ps = strtok(NULL, ":;,");

//    printf("%s ", ps);

//

//    ps = strtok(NULL, ":;,");

//    printf("%s ", ps);

//

//    ps = strtok(NULL, ":;,");

//    printf("%s ", ps);

//

//    ps = strtok(NULL, ":;,");

//    printf("%s ", ps);

//

//    return 0;

//}

//int main(int argc,const char *argv[])

//{

//    char str[100]="root:qian;:feng,:jiao;yu";

//    

//    char *pstr = str;

//    while ((pstr = strtok(pstr, ":;,"))) {

//        printf("%s ",pstr);

//        pstr = NULL;

//    }

//

//    return 0;

//}

//查找子串

//strstr

//char *strstr(const char *src, const char *subStr);

//返回子串在原串中第一次出现的地址,原串中没有该子串返回NULL

char *my_strstr(const char *src, const char *substr)

{

    char *sub = (char *)substr;

    while (*src) {

        char *temp = (char *)src;

        while (*src++ == *substr++) {

            if (*substr == '') {

                return temp;

            }

        }

        src = temp+1;

        substr = sub;

    }

    return NULL;

}

//int main(int argc,const char *argv[])

//{

//    char src[100]="hello wwworldqian world feng";

//    printf("%s ", my_strstr(src, "world"));

//    

//    return 0;

//}

//"qianarefengarejiaoareyu"

//"are"

//qian feng jiao yu

//int main(int argc,const char *argv[])

//{

//    char str[100]="qianarefengarejiaoareyu";

//    char *p,*q;

//    p = q = str;

//    int len = strlen("are");

//    while ((p = strstr(p, "are"))) {

//        *p = '';

//        printf("%s ",q);

//        p+= len;

//        q = p;

//    }

//    if (*q) {

//        printf("%s ", q);

//    }

//    return 0;

//}

//sscanf sprintf

//int sscanf(const char * , const char * , ...)

//int sprintf(char * , const char * , ...);

int main(int argc,const char *argv[])

{

    char str[100]="$GPGGA,4250.5589,S,14718.5084,E";

    char header[100]={};

    char ch1, ch2;

    float south;

    float east;

    sscanf(str, "%6s,%f,%c,%f,%c",header,&south,&ch1,&east,&ch2);

    printf("%.2f %.2f ", south, east);

    char buf[100];

    sprintf(buf, "%d***%d",12,45);

    printf("%s ", buf);

    

    return 0;

}

//sscanf sprintf  字符串

//scanf printf    标准输入输出文件 stdin stdout

//fscanf fprintf  文件

//int main(int argc, const char * argv[]) {

////    int a, b;

////    fscanf(stdin, "%d%d", &a, &b);

////    fprintf(stdout, "a = %d b = %d ", a, b);

//    

//    int a, b;

//    int ret = sscanf("12**34", "%d**%d",&a,&b);//返回解析变量成功个数

//    printf("a = %d b = %d ", a, b);

//    printf("ret = %d ", ret);

//    

//    float f1 = 3.14;

//    char buf[100]={};

//    

//    ret = sprintf(buf, "%f####%d****%d",f1,a,b);

//    printf("%s ",buf);

//    printf("ret = %d ", ret);

//    

//    return 0;

//}

//把字符串转换成整型

//atoi

//int atoi(const char *);

//double atof(const char *);

//long atol(const char *);

int my_atoi(const char *src)

{

    int val=0;

    int inter = 1;

    while (isspace(*src)) {

        src++;

    }

    if ((*src=='-')||(*src=='+')) {

        if (*src=='-') {

            inter =-1;

        }

        src++;

    }

    while (isdigit(*src)) {

        val = val * 10 + digittoint(*src);

        src++;

    }

    return val*inter;

}

//int main(int argc,const char *argv[])

//{

//    char str[100]={};

//    scanf("%s", str);

//    

//    printf("%d ", my_atoi(str));

//    return 0;

//}