day05(补) 字符数组 字符串操作函数 宏定义

   // 数组元素存储的是字符
#pragma mark- 字符数组
    // 定义字符数组
   // char a[5]={'h','e','l','l','o'};
    //char b[]={'h','e','l','l','o'};
    //char c[10]={'h','e','l','l','o'};
   // char d[]="hello";
   
    // 默认设置 '\o' ， '\o' 是空操作符，不显示。
   
    // 修改前
//    for (int i=0; i<5; i++) {
//        printf("%c",b[i]);
//    }
//    printf("\n");
//    // 访问和修改
//    b[1]='a';
//    for (int i=0; i<5; i++) {
//        printf("%c",b[i]);
//    }
//    printf("\n");
//   
//    c[1]='\0';
//    for (int i=0; i<5; i++) {
//        printf("%c",c[i]);
//    }
   
    // 字符串
    //1. 字符串常量， “hello world”
    //2. 使用字符串数组存储字符串
    //3. 使用 %s, 输出字符串
   
    // 定义字符串数组存储字符串
    //char a[]="hello world";
   
    // 系统如何识别字符串： ‘\0’, 数据存储在内存中，系统识别那些字符属于一个完整的字符串。
    //‘\0’ 是字符串结束标志，在字符串的最后一位，由系统默认添加，空操作，不可以显示。
    //"hello " 存储时 ，实际上是 'h','e','l','l','o','\0'
    // 有效字符：在字符串中， \0 之前的都是有效字符
    // 存储字符串的字符数组元素个数 = 有效字符个数 + 1

    // 输出字符串
//printf("%s\n",a);
   
    // 字符串和字符数组的关系
    //1. 字符串是一个字符数组
//    char a1[]="hello";
//    char b1[]={'h','e','l','l','o'};
//    printf("%s",b1);
    //a 和 b 都是数组
    //1. 两个数组中存储的内容都是字符串   hello
    //2. 字符数组不一定是一个字符串
    //3. 都可以访问，修改数组元素，遍历
//    a1[0]='a';
//    for(int i=0;i<sizeof(b1)/sizeof(char);i++)
//    {
//        //printf("a1[%d]=%c,b1[%d]=%c\n",i,a1[i],i,b1[i]);
//       
//        printf("b1[%d]=%c\n",i,b1[i]);
//    }
    //2. 字符数组不一定是一个字符串
//    char a[]={'L','a','n','o','u'};
//    char b[]="Lanou";
    //a 和 b 都是字符数组
    // 数组 a 中存储了 5 个字符；数组 b 中存储了 6 个字符，存储的是一个字符串
    // 使用 {} 方式初始化字符数组时，如果数组元素包括 '\0' ，存储的内容才能成为字符串
    // 练习
    //char a[]="xiAn lanou";// 数组中 a 有几个元素，有几个有效字符呢     11 10
    //printf("%ld",sizeof(a));
    //char b[20]="beijing lanou";// 数组中 b 又有几个元素呢？几个有效字符呢 ? 20 13
   // printf("%ld",sizeof(b));
   
    //3. 存储字符串数组，可以输出单个字符，也可以使用 %s 输出完整 字符串，使用 %s 输出时，遇到 '\0' 时结束输入
//    char a[]="lanou";
//    for (int i=0; i<6; i++) {
//        printf("%c\n",a[i]);
//    }
//    printf("\n");
//    printf("%s\n",a);
//    char b[]={'l','a','\0','o','u','\0'};
//    printf("%s\n",b);
    //4. 只是存储字符的数组，只能输出单个字符
//    char a[]={'l','a','n','o','u'};
//    for (int i=0; i<5; i++) {
//        printf("%c",a[i]);
//    }
//    printf("\n");
//    printf("%s",a);
#pragma mark- 字符串操作函数
    //1.strlen 测量字符串的长度
    //2. 测量的是字符串的实际长度，不含 '\0'
//    char name[]="wangnima";
//    printf("%s 的实际长度 %lu\n",name,strlen(name));
   
    //strcpy 字符串拷贝
//    char a[10]={0};
//    char b[]="lanou";
    //strcpy( 字符数组 1 ，字符数组 2);
    // 将字符串 2 复制到字符数组 1 中
//    strcpy(a, b);
//    printf("%s\n",a);
    // 字符串 2 是常量，字符数组名 strcpy(a,"wangnima");
    // 字符数组 1 的存储空间 >= 字符串 2
//    char a[10]={0};
//    char b[]="lanou";
    // 注：给一个字符数组赋值，只能使用 strcpy ，不能直接对一个字符数组赋值。
    //a=b;// 错误
    //3.strcat 拼接
//    char a_1[30]="hello ";
//    char b_1[]="lanou";
    //strcat( 字符串数组 1, 字符串数组 2);  将字符串 2 拼接到字符串 1 后面，结果保留在字符串 1 中
    // 字符数组 2 可以是常量
    // 字符数组 1 的存储空间必须足够大
    // 拼接之后，字符串 1 的 ‘\0’ 取消，只能在新的字符串后面保留 '\0'
//    strcat(a_1, b_1);
//    printf("a_1=%s,b_1=%s\n",a_1,b_1);
    // 字符串的比较
//    char a[]="apple";
//    char b[]="goole";
    //strcmp  字符串的比较
    // 将 2 个 字符串自左向右逐个比较（按照 ASII 码值大小比较 ), 直到出现不同的字符或遇 '\0' 为止
    // 字符串 1 的字符 >= 字符串 2 的字符
    // 字符串 1= 字符串 2 ，则函数结果为 0
    // 字符串 1 <= 字符串 2 ，则结果为负整数
//    printf("%d\n",strcmp(a, b));// 字符串 1 < 字符串 2
//    printf("%d\n",strcmp(b, a));// 字符串 1 > 字符串 2
//    printf("%d\n",strcmp("apple","apple"));// 字符串 1 = 字符串 2
//   
//    printf("%d\n",strcmp("app","appl"));// 字符串 1 < 字符串 2
    // 练习：查找字符串中的空格数
    // 比如 :"I love iOS, i want an iPhone6"
//    char str[]="I love iOS, i want an iPhone6";
//    int count=0;
//    for (int i=0; i<sizeof(str)/sizeof(char); i++) {
//        if (str[i]==' ') {
//            count++;
//        }
//    }
//    int n=0;
//    while (str[n]!='\0') {
//        if (str[n]==' ')
//        {
//            count++;
//        }
//        n++;
//    }
//    printf("count=%d",count);
    // 练习：将字符串 倒转，例如 “afjnpue” ，转成字符串 “eupnjfa” （是改变字符串本身，而不是反向输出）
   
//    char str[]="afjnpue";
//    int length=(int)strlen(str);// 强转
//    //printf("%d\n",length);
//    for (int i=0; i< length/2; i++)
//    {
//        int tmp=str[i];
//        str[i]=str[length-1-i];
//        str[length-1-i]=tmp;
//    }
//   

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

#pragma mark-宏定义

    // 宏定义的概念及参宏定义方法
    //1. 宏的概念
    // 被定义为 “ 宏 ” 的标识符被称为 “ 宏名 ” ，在编译过程中，对程序中所有出现的 “ 宏名 ” 都换成宏定义中的字符串去代换，宏定义中是由源程序中的宏定义命令完成的，宏代换事由预处理程序自动完成的。在 c 语言中，宏分为有参宏和无参宏两种。
    // 预处理：概念。以 # 号开头的预处理命令，如包含 #include. 宏定义命令 #define 等。在源程序中这些命令都放到函数之外，我们称他们为预处理部分。
    // 凡是以 # 开头的均为预处理命令， “define” 为宏命令。 “ 标识符 ” 为所定义的宏名，字符串可以事常量，表达式，格式串等等
    //#undef PI
    // 无参宏的使用注意事项：
    //1. 习惯上宏名用大写字母表示，以便于变量区别，但也允许用小写字母。
    //2. 宏定义不是说明语句，在行末不必加 “ ； ” 号，如果加 “ ； ” ，会将 “ ； ” 一并替换。
    //3. 宏名在源程序中若用 “” 括起来，则预处理程序不对其做宏替换
    //4. 宏定义允许替换，在宏定义的字符串中可以使用已经定义的宏名，在宏展开是由预处理程序层代换。
#define PI 3.1415
#define H helloworld
#define STU struct stu
#define INT int
#define p printf
#define D "%d\n"
    INT a= 12 ;
    struct stu
    {
        char *name;
        int age;
    };
    STU s1={ "sb" ,a}; // 定义一个结构体并赋值
    printf ( "name:%s,age:%d" ,s1. name ,s1. age );

    p(D,s1.age);

//有参宏
    //#define 宏名（形参） 字符串
    //字符串中含有个个形参
    //带有宏调用的一般形式为 #define M(y) y*y+3*y
#define M(y) y*y+3*y
#define SUM(a,b)  a+b
    INT k=M(5);
    printf("%d\n",k);
    printf("%d\n",SUM(12,65));

 //注意事项：1.带参宏 定义中，形参之间可以出现空格，但是宏名和形参之间不能有空格出现。
    //2.在宏定义中的形参事标示符，而宏调用中的实参可以是表达式；在宏定义中，字符串内的形参通常要用括号括起来，意面出错。
    //如上例：(x)*(y)表达式的y都用括号括起来，因此结束是正确的。
    //4.宏定义也可以用来定义多个语句，在宏调用时，把这些语句又替换到源程序中。
#define JI(a,b)  a=i+3; b=j+4;
#define MAX(a,b) (a>b)? a:b
    int i=4,j=2;
    int m=0;
    int n=0;
    JI(m,n);
    printf("i=%d,j=%d\n",m,n);
    printf("max=%d",MAX(i, j));