C语言【C语言】9.指针,字符串和勤组的补偿,指针函数&函数指针,结构体,枚举

  • 只有指针是得运算(移动)的,数组名是未得以的。

     int x[10];
     x++;  //illegal
     int* p = x;
     p++; //legal
    
  • 零星依赖针变量相减所得的异是少数只指针所指数组元素之间相差的素个数。

    • 骨子里是简单单依靠针值(地址)相减之异又除为该数组元素的长度(字节数)。
    • (pointer2地址值 – pointer地址值) / sizeof(所对数据类型)
    • 指南针之间可以相减,但不得以相加(相加无意义)。
  • 概念字符串:

    • 字符数组:

      char string[] = "hello";
      printf("%s\n",string);
      
    • 字符串指针指为字符串:

      char *str = "hello"
      
  • 利用字符数组来保存之字符串是是”栈”里之,所以它们是只是读而写的,所以我们得以修改字符数组里的某个元素的价。

    然,使用字符指针来保存字符串,它保存的是字符串常量地址,”常量区”是独读之,所以是不行更改的。

    char *str = "hello";
    *(str+1) = 'w'; // 错误
    
  • 利用注意:

    char *str;
    scanf("%s", str); 
    
    /* str是一个野指针,他并没有指向某一块内存空间,所以不允许这样写。如果给str分配内存空间是可以这样用的 */
    
     /********* 数组的方法****************/  
    
     char name[20];  
     scanf("%s",name);    
    
    /************* 给字符针针分配内存空间的办法***********/  
    
     char *name;  
     name=(char*)malloc(50);      //此时name已经指向一个刚刚分配的地址空间。  
     scanf("%s",name);  
    

  • 指针函数(是函数,返回值是指针)注意:

    倘函数返回一个字符串,那么一旦就此一个数组以下面的花样来连接的语句,是会报错的:

    char *test() {
        return "hello";
    }
    
    int main(int argc, const char * argv[]) {
    
        char names[10];
    
        names = test();
    
        return 0;
    }
    

    这是为,返回的字符串相当给一个这样的数组:{‘h’, ‘e’, ‘l’, ‘l’,
    ‘o’,
    ‘\0’},但是前我们说过,数组如果当概念的时节从不就此{}这种办法初始化,那么后面就是非克再次就此这种方式初始化了,所以会见出错。

    缓解办法:将char names[10]改为char *names或者char
    names[10]直接当test()

  • 函数指针(是指针,指于函数):

    • 格式:函数的返值类型 (*指南针变量名) (形参1, 形参2, …);

      int sum(int a,int b)
      {
        return a + b;
      }
      
      int (*p)(int,int);
      p = sum;
      
    • 运场景:

      • 调用函数

      • 以函数作为参数在函数间传递

      • 函数指针能再次灵活:

        int minus(int a, int b) 
        {
          return (a - b);
        }
        
        int add(int a, int b)
        {
          return (a + b);
        }
        
        int myFunction(int a, int b, int (*funcP) (int, int))
        {
          return funcP(a, b);
        }
        
        int main()
        {
          int minusResult = myFunction(10, 20, minus);
            int addResult = myFunction(10, 20, add);
              ...
          return 0;
        }
        
        /*
          函数指针能让程序更灵活,比如后续有乘、除函数的时候,只需实现这两个函数然后在主函数调用myFunction函数即可。如果是多人协作,不同的人写不同的功能,如果我们来写myFunction那么基本就不用修改就可以一直使用,非常灵活。
        */
        

    • 技巧:

      1、把要指向函数头拷贝过来

      2、把函数名称使用小括号括起来

      3、在函数名称前加上一个*

      4、修改函数名号

    • 运用注意:

      • 鉴于当下类似指针变量存储的是一个函数的入口地址,所以针对它们作加减运算(比如p++)是空虚的。

      • 要上例,如果想使用p这个函数指针,可以一直通往利用sum一样:

        int result = p(10, 10);
        

        呢得这样:

        int result = (*p)(10, 10);
        

  • 结构体是同样栽从今定义数据类型,注意,它是数据类型

    struct Student {
         char *name;
         int age;
     };
    
     struct Student stu;
    

    注意,结构体的末尾是产生 ; 的。

  • 在动结构体类型的时节,要抬高struct关键字。

  • 概念结构体类型的以定义变量:

    struct Student {
        char *name;
        int age;
    } stu;
    

    这种当概念之同时也定义了变量,就一定给:

    struct Student {
         char *name;
         int age;
     };
    
     struct Student stu;
    

    概念结构体类型的还要定义变量,以后如果想延续应用这组织体类型,仍然可以利用正规的点子定义:

    struct Student newStu;
    
  • 匿名结构体定义结构体变量:

    struct {
        char *name;
        int age;
    } stu;
    

    这种匿名方式同方的法对比,虽然看起再次精简(省去了结构名),但是只要顾,这只能定义一个stu变量,而未克更定义新的变量,因为组织名尚未了。

  • 结构体变量的初始化:

    1. 优先定义结构体变量,然后再初始化

      struct Student {
           char *name;
           int age;
       };
      
      struct Student stu = {“QY", 21};
      
    2. 概念之还要初始化

      struct Student {
           char *name;
           int age;
       } stu = {“QY", 21};
      
    3. 可以使另外一早已有的组织体初始化新的结构体

      struct Student stu2 = stu;
      
    4. 优先定义stu再初始化(与1对准诺):

      struct Student stu3;
      stu3 = (struct Student){"QY", 21};
      
      /*
      这种情况要与数组对应起来,因为前面说过数组是不可以这样子的,其实结构体是可以的,但是要加上强制类型转换,告诉编译器这不是数组而是一个结构体。
      */
      
    5. 脚的做法是大错特错的:

    6. struct Student {

           char *name;
           int age;
       };
      struct Student stu;
      stu = {“QY", 21}; // 错误,需要强制类型转换
      
    7. 要么以这种艺术来叫成员赋值:

      struct Student {
           char *name;
           int age;
       };
       struct Student stu;
      
       stu.age = 27;
      
  • 结构体变量占用存储空间大小

    1. 找到成员里占用字节最可怜的来分配空间,如int a, double b, char
      c,则一律赖分配8个字节。要专注对旅的问题来拘禁共多少只字节。注意声明变量的逐条,不同顺序分配的字节数也非雷同。比如现在此顺序要分配8 +
      8 + 8单字节,但是要是int a, char c, double b则分配 8 + 8独字节。

    2. 得经过#pragma
      pack(2)
      来设置针对齐模数,这样同样软分配2只字节。

      struct A
      {
          int my_test_a; // 分配2次,共4个字节
          char my_test_b; //分配1次,共2个字节
          double my_struct_a; //分配4次,共8个字节
          int my_struct_b; //分配2次,共4个字节
          char my_struct_c; //分配1,共2个字节
      }
      
      /* 结果是共有20个字节。
      */
      
  • 结构体数组:

    同结构体变量一样,结构体数组也闹3种植概念方式 :

    • 事先定义结构体类型,再定义结构体数组

      struct Student {
          char *name;
          int age;
      };
      struct Student stu[5];
      
    • 概念结构体类型的而定义结构体数组

      struct Student {
          char *name;
          int age;
      } stu[5];
      
    • 匿名结构体定义结构体结构体数组

      struct {
          char *name;
          int age;
      } stu[5];
      

    结构体数组初始化:

    • 概念的还要开展初始化

      struct { 
        char *name; 
        int age; 
      } stu[2] = { {"jo", 27}, {"y", 30} };
      
    • 优先定义,后初始化,整体赋值

      s[1] = (struct stu){23,"hello"};
      
    • 先定义,后初始化 分开赋值

      s[1].age=12; 
      strcpy(stu[1].name, "hello");
      
  • 结构指针变量中之价是所对的布局变量的首地址

  • struct 结构名 *结构指针变量名

  • 示例:

    // 定义一个结构体类型
    struct Student {
        char *name;
        int age;
    };
    
    // 定义一个结构体变量
    struct Student stu = {“QY", 21};
    
    // 定义一个指向结构体的指针变量
    struct Student *p;
    
    // 指向结构体变量stu
    p = &stu;
    
    /*
    这时候可以用3种方式访问结构体的成员
    */
    // 方式1:结构体变量名.成员名
    printf("name=%s, age = %d \n", stu.name, stu.age);
    
    // 方式2:(*指针变量名).成员名
    printf("name=%s, age = %d \n", (*p).name, (*p).age);
    
    // 方式3:指针变量名->成员名
    printf("name=%s, age = %d \n", p->name, p->age);
    
  • 透过结构体指针访问结构体成员:

    • (*结构指针变量).成员叫
    • 组织指针变量->成员叫(用熟)
    • (pstu)两侧的括号不可少,因为成员称“.”的预先级高于“”。
      如错过掉括号做pstu.num则等效于(pstu.num),这样,意义就全盘不对了。
  • 当就此结构指针的下,就将她当做int *a来看,比如:

    struct Student stu = ... //相当于 int a = ...
    struct Student *p; //相当于 int *p
    p = &stu; //相当于 p = &a
    
  • 结构体变量作为参数传递是价值传递,而构造指针则是址传递。

  • 枚举:

    枚举通常是有的稳的取值范围,如一年四季,一全面七龙这种。

    同结构体类似:

    enum 枚举名 {
        枚举元素1,
        枚举元素2,
        ……
    };
    
    enum Season {
        spring,
        summer,
        autumn,
        Winter
    };
    enum Season s;
    定义枚举类型的同时定义枚举变量
    enum Season {
        spring,
        summer,
        autumn,
         winter
    } s;
    省略枚举名称,直接定义枚举变量
    enum{
        spring,
         summer,
         autumn,
         winter
    } s;
    
    s = spring; //等价于s = 0;
    s = 3; //等价于s = winter;
    

    枚举类型本质上的话即使是整形,默认为0,1,2,3…,但是也得以赋值,比如第三单赋值为10,那么第1只呢0,第2独为1,第3独也10,第4个也11。

    普通来说,枚举的正统也:以k + 枚举名称 + 枚举元素名。比如:

    enum Season {
        kSeasonSpring,
        kSeasonSummer,
        kSeasonAutumn,
        kSeasonWinter
    };
    
    enum Season s = kSeasonSummer;