C语言_字符和字符串

//***** 字符 *****
void test1()
{
    char ch = 'a';
    printf("%c\n",ch);

    /*
    char这是字符类型，打印字符类型，必须使用%c格式符
    */
}

//***** 字符数组 *****
void test2()
{
    char a[5] = {'a','b','c','d','e'};
    for(int i = 0; i < 5; i ++)
    {
        printf("%c\n",a[i]);
    }
}

//***** 二维字符数组 *****
void test3()
{
    char a[2][3] = {{'a','b','c'},{'d','e','f'}};
    for(int i = 0; i < 2; i ++)
    {
        for(int j = 0; j < 3; j ++)
        {
            printf("%c\t",a[i][j]);
        }
        printf("\n");
    }
}

//***** 字符串 *****
void test4()
{
    char a[6] = {'a','b','c','d','e','\0'};
    printf("%s\n",a);
    /*
    字符串，其实就是以空字符结尾的字符数组，空字符也就是字符串的结束标志，所以，"字符数组"就是"字符串"
    记住，"字符数组"就是"字符串"
    数组的长度也包括空字符
    */
}

//***** 字符串初始化 *****
void test5()
{
    char a1[6] = {'a','b','c','d','e','\0'};  // 第一种初始化
    char a2[6] = {"abcde"};  // 第二种初始化，"abcde" 等于 'a','b','c','d','e','\0'
    char a3[] = {"abcde"};  // 第三种初始化
    char a4[] = "abcde";  // 第四种初始化
    char *a5 = "abcde";  // 第五种初始化

    printf("a1:%s\n",a1);
    printf("a2:%s\n",a2);
    printf("a3:%s\n",a3);
    printf("a4:%s\n",a4);
    printf("a5:%s\n",a5);
}

//***** 数组的输入 *****
void test6()
{
    char a[5] = {0};
    printf("请输入字符串,不超过5个字符:\n");
    scanf("%s",a);  // 由于格式符为%s，系统会自动在字符串的最后添加结束符
    printf("你输入的字符串为:%s\n",a);

    /*
    scanf 遇到空格符、回车符、换行符、换页符和制表符都会终止一个数据的输入
    scanf 实际上是一个缓冲区输入流获取函数
    */

    char b[5] = {0};
    printf("请输入字符串,不超过5个字符:\n");
    gets(b);
    printf("你输入的字符串为:%s\n",b);

    /*
    gets 是专门的字符串输入获得函数
    */
}

//***** 字符串长度 *****
void test7()
{
    char a[6] = {'a','b','c','d','e','\0'};
    int length = 0;
    length = strlen(a);
    printf("length:%d\n",length);

    /*
    strlen 函数可以获得字符串的长度，而这个长度不包括字符串结束符
    */
}

//***** 字符串大写转成小写 *****
void test8()
{
    char a[] = "HELLO WORLD";
    printf("转换前:%s\n",a);
    strlwr(a);
    printf("转换后:%s\n",a);

    /*
    strlwr 函数可以将字符串大写转换成小写
    */

    /*
    C语言中，操作字符串没有字符串副本，操作的永远是字符串本身，所以strlwr没有返回值
    */
}

//***** 字符串小写转成大写 *****
void test9()
{
    char a[] = "hello world";
    printf("转换前:%s\n",a);
    strupr(a);
    printf("转换后:%s\n",a);

    /*
    strlwr 函数可以将字符串小转换成大写
    */
}

//***** 字符串输出 *****
void test10()
{
    char a[] = "hello world";

    // 第一种输出
    printf("字符串:%s\n",a);

    // 第二种输出
    puts(a);

    /*
    printf 输出要指明输出格式
    puts 输出不用指明输出格式，也就是不能输出格式化，建议采用第一种printf输出格式
    */
}

//***** 字符串复制strcpy *****
void test11()
{
    char a[] = "Hello World";
    printf("复制前:%s\n",a);
    strcpy(a,"cxm");
    printf("复制后:%s\n",a);

    /*
    strcpy 一个字符串复制函数
    */
}

//***** 字符串拼接strcat *****
void test14()
{
    char a[] = "Hello World";
    char b[] = "cxm";
    printf("拼接前:%s\n",a);
    strcat(a,b);
    printf("拼接后:%s\n",a);

    /*
    strcat 字符串拼接函数
    */
}

//***** 字符串拼接strncat *****
void test15()
{
    char a[] = "Hello World";;
    char b[] = "cxm";
    printf("拼接前:%s\n",a);
    strncat(a,b,2);
    printf("拼接后:%s\n",a);

    /*
    strncat 也是字符串拼接函数，但可以指定拼接的长度，这是strncat和strcat区别最大的地方
    */
}

//***** 字符串查找strchr *****
void test16()
{
    char a[] = "Hello World";;
    char c = 'H';
    char *ptr = NULL;
    ptr = strchr(a,c);
    if(ptr)
    {
        printf("该字符所在的位置:%d\n",ptr - a);
    }
    else
    {
        printf("没有找到该字符!\n");
    }

    /*
    strnchr 是一个在字符串中查找字符的函数
    */
}

//***** 字符串设置strset *****
void test17()
{
    char a[] = "Hello World";
    printf("设置前:%s\n",a);
    strset(a,'a');
    printf("设置后:%s\n",a);

    /*
    strset 快速把字符串设置为某个字符的函数，平时经常使用
    */
}

//***** 字符串比较strcmp *****
void test18()
{
    char a[] = "Hello World";
    char b[] = "cxm";
    int result;
    result = strcmp(a,b);
    if(result < 0)
    {
        printf("字符串a小于字符串b!\n");
    }
    else if(result == 0)
    {
        printf("字符串a等于字符串b!\n");
    }
    else
    {
        printf("字符串a大于字符串b!\n");
    }

    /*
    strcmp 是一个比较字符串的函数，比较结果为整数，结果按递增规律，从小到大排列
    */
}

//***** 字符串反转strrev *****
void test19()
{
    char a[] = "Hello World";
    printf("反转前:%s\n",a);
    strrev(a);
    printf("反转后:%s\n",a);

    /*
    strrev 是一个字符串反转函数，也即是把字符串倒序过来
    */
}

//***** 字符串查找子字符串strstr*****
void test20()
{
    char a[] = "Hello World";
    char b[] = "ll";
    char *ptr = NULL;
    ptr = strstr(a,b);
    if(ptr)
    {
        printf("该字符所在的位置:%d\n",ptr - a);
    }
    else
    {
        printf("没有找到该字符!\n");
    }
}

//***** 内存复制memcpy *****
void test12()
{
    char a[] = "Hello World";
    char b[] = "cxm";
    printf("复制前:%s\n",a);
    memcpy(a,b,2);
    printf("复制前:%s\n",a);
    /*
    memcpy 是一个内存复制的函数，"mem"开头都是和内存操作有关的函数
    memcpy 有三个参数，第一个是目的操作数，第二个是源操作数，第三个是指定复制长度
    memcpy 可以指定复制的长度，这是和strcpy重要的区别
    */
}

//***** 内存复制memccpy *****
void test13()
{
    char a[] = "Hello World";
    char b[] = "cxm";
    printf("复制前:%s\n",a);
    memccpy(a,b,'m',3);
    printf("复制前:%s\n",a);

    /*
    memccpy 也是一个内存复制的函数
    memccpy 但它有四个参数，第一个是目的操作数，第二个是源操作数，第三个是停止复制的字符，第四个是指定复制长度
    memccpy 可以指定复制的长度，这是和strcpy重要的区别
    */
}

//***** 字符指针和字符串指针 *****
void test21()
{
    char ch = 'e';
    char *ptr = NULL;

    // 字符指针
    ptr = &ch;
    printf("字符:%c\n",*ptr);

    // 字符串指针
    ptr = "cxm";
    printf("字符串:%s\n",ptr);

    // 从上面可以看出，"字符指针"和"字符串指针"是一样
    /*
    字符指针既可以保存字符的地址，也可以保存字符串的地址，这点很重要
    字符地址，比较容易理解
    字符串地址，其实就是第一个字符地址，所以两者实际上是一样的
    只要知道字符串的第一个字符地址，通过指针加操作，就可以不断地访问下一个字符，一直到字符串结束符，从而访问整个字符串
    */
}

//***** 字符串常量 *****
void test22()
{
    char *ptr = "Hello World";
    printf("%s\n",ptr);
    /*
    上面已经介绍过，字符串初始化的方法有5种，第5种就是字符串指针初始化法
    */
}

//***** 字符串删除特定字符 *****
void test23()
{
    char *ptr = "Hello World";
    char des[20] = {0};
    char search;
    int i;
    printf("请输入一个要删除的字符:\n");
    scanf("%c",&search);

    for(i = 0; (*ptr) != '\0'; i ++)
    {
        if((*ptr) != search)
        {
            des[i] = *ptr;
        }
        else
        {
            i --;
        }
        ptr ++;
    }
    des[i] = '\0';

    printf("删除特定字符后的字符串:%s\n",des);
}

//***** 字符指针数组 *****
void test24()
{
    char *s[] = {"张三","李四","赵钱","孙李","周吴","郑王"};
    int n = sizeof(s) / sizeof(char *);
    for(int i = 0; i < n; i ++)
    {
        printf("%s\n",s[i]);
    }
}