【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;
    }
    

    那是因为,重回的字符串相当于1个那样的数组:{‘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那么基本就不用修改就可以一直使用,非常灵活。
        */
        

    • 技巧:

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

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

      三 、在函数名称后边加上三个*

      4、修改函数名称

    • 使用注意:

      • 是因为那类指针变量存储的是1个函数的进口地址,所以对它们作加减运算(比如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;
    

    那种匿名格局与地方的情势相比,即使看起来更简明(省去了协会名),不过要留心,这只可以定义3个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 + 几个字节,不过一旦int a, char c, double b则分配 8 + 九个字节。

    2. 可以通过#pragma
      pack(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
    
  • 结构体变量作为参数传递是值传递,而构造指针则是址传递。

  • 枚举:

    C语言,枚举平时是部分定点的取值范围,如一年四季,七天七日那种。

    与结构体类似:

    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个赋值为10,那么第2个为0,第三个为1,第③个为10,第几个为11。

    常见来说,枚举的标准为:以k + 枚举名称 + 枚举成分名。比如:

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