高级指针 (C语言)

指针 

 

指针在函数中的使用

交换两个变量的值(函数)

void swap(int m, int n);
void swap(int m, int n){
    int temp = 0;
    temp = m;
    m = n;
    n = temp;
}

int a = 5, b = 10;
    swap(a, b);
    printf("a = %d
b = %d
", a, b);//a 和 b没有交换,交换的是m n

a 和 b没有交换,交换的是m n

如果想要在函数内部修改函数外部定义的变量, 就需要传递指针

void swapPro(int *p1, int *p2);
void swapPro(int *p1, int *p2){
   int  temp = *p1;
        *p1 = *p2;
        *p2 = temp;
}
 swapPro(&a, &b);
    printf("a = %d
b = %d
", a, b);

写一个冒泡排序的函数

void bubble(int a[], int count);
void bubble(int a[], int count){
    for (int i = 0; i < count - 1; i++) {
        for (int j = 0; j < count - 1 - i; j++) {
            if (a[j] > a[j + 1]) {
                //1.
                int temp = a[j];
                a[j] = a[j + 1];
                a[j + 1] = temp;
                //2.
//                int temp = *(a + j);;
//                *(a + j) = *(a + j + 1);
//                *(a + j + 1) = temp;
                //3.
                //swapPro(a + j, a + j + 1);
                //4.
                //swapPro(&a[j], &a[j + 1]);
                
            }
        }
    }
}
//打印数组的函数
void printArray(int *p, int count);
void printArray(int *p, int count){
    for (int i = 0; i < count; i++) {
        printf("%d ", *(p + i));
    }
    printf("
");
}
int array[5] = {2, 3, 5, 4, 1};
    bubble(array, 5);
    printArray(array, 5);

指针在结构体中的使用

结构体声明

struct student{
        char name[20];
        char gender;
        int age;
    };

对结构体重命名

 //定义结构体变量
    Student stu = {"zhangsan", 'f', 18};
    
    //访问结构体里的成员变量(点语法)
    printf("%s
", stu.name);
    printf("%c
", stu.gender);
    printf("%d
", stu.age);

结构体变量所占的字节数

    printf("%lu
", sizeof(Student));//28

    printf("%p
", &stu);
    
    //定义结构体指针变量, 存结构体变量的首地址
    Student *p = &stu;
    
    //*p 取到结构体变量stu
    printf("%s
", (*p).name);
    printf("%c
", (*p).gender);
    printf("%d
", (*p).age);

有了结构体变量的首地址, 可以使用->(指向操作符)访问成员变量

    printf("%s
", p->name);
    printf("%c
", p->gender);
    printf("%d
", p->age);

定义一个点坐标的结构体CPoint，包含两个float 成员x,y。

1.定义两个CPoint结构体变量m,n

2.使用两个结构体指针分别指向m,n

3.然后通过指针计算两点距离（提示：1、勾股定理，2、开方函数sqrt）

typedef struct{
        float x;
        float y;
    }Cpoint;
    
    Cpoint m = {6.0, 4.0};
    Cpoint n = {2.0, 1.0};
    Cpoint *pm = &m;
    Cpoint *pn = &n;
    
    //m.x - n.x
    //(*pm).x - (*pn).x
    float distance = sqrt((pm->x - pn->x) * (pm->x - pn->x) + (pm->y - pn->y) * (pm->y - pn->y));
    //powf: 平方函数
    //float distance = sqrt(powf((pm->x - pn->x), 2) + powf((pm->y - pn->y), 2));
    printf("两点距离: %.2f
", distance);

把下面结构体变量中的名字中的空格改成下划线

 Student stu1 = {"zhang san feng", 'm', 999};

//结构体声明
    struct student{
        char name[20];
        char gender;
        int age;
    };
    
    
    //对结构体重命名
    typedef struct student Student;
    
    //把下面结构体变量中的名字中的空格改成下划线
    Student stu1 = {"zhang san feng", 'm', 999};
    //1
    strcpy(stu1.name, "zhang_san_feng");
    //2
    stu1.name[5] = '_';
    stu1.name[9] = '_';
     //3
    for (int i = 0; i < strlen(stu1.name); i++) {
        if (stu1.name[i] == ' ') {
            stu1.name[i] = '_';
        }
    }
    //4
    int i = 0;
    while (stu1.name[i] != '') {
        if (stu1.name[i] == ' ') {
            stu1.name[i] = '_';
        }
    }

    //5
    char *p2 = stu1.name;
    int j = 0;
    while (*(p2 + j) != '') {
        if (*(p2 + j) == ' ') {
            *(p2 + j) = '_';
        }
    }
    //6
    Student *p = &stu1;
    int k = 0;
    while (p->name[k] != '') {
        if (p->name[k] == ' ') {
            p->name[k] = '_';
        }
    }

指针: 内存地址编号

指针变量: 存储指针

int a = 10;

int *p = NULL;

p = &a;

指针变量所占的字节数只和操作系统有关

指针变量的数据类型: 1. *p  2. p + 1

    指针的应用

   1.数组: 在内存中连续存储; 数组名是数组的首地址: a[i] = *(a + i)

   2.字符串: %s的实质

   3.函数: 在函数内部修改函数外部定义的变量, 需要传递指针, 例如scanf,bubble排序

   4.结构体: Student *p, p->name, 通过指向操作符作为结构体的成员变量

   5.结构体数组

   6.指针数组

   指针在结构体数组中的使用

Student s[5] = {
        {"zhangsan", 'm', 18},
        {"lisi", 'f', 88},
        {"wangmazi", 'f', 38},
        {"jiujing", 'm', 16},
        {"change", 'f', 998}
    };

数组的首地址: s

结构体数组所占的字节数: 28 * 5

     *s = s[0]

    *(s + i) = s[i]

    s: 第一个元素的首地址

    s + i: 第i + 1个元素的首地址

 

    如何取到第一个元素的name

    s[0].name   s[i].name

    (*s).name   (*(s + i)).name

    s->name     (s + i)->name

   

    遍历结构体数组, 打印每一个元素

 for (int i = 0; i < 5; i++) {
        printf("%s %c %d
", s[i].name, (s + i)->gender, (*(s + i)).age);
      }
    
    printf("
");

把结构体数组中的姓名首字母大写, 年龄都加10

for (int i = 0; i < 5; i++) {
        //判断首字母是否为小写
        if (s[i].name[0] >= 'a' && s[i].name[0] <= 'z'){
            //改成大写
            s[i].name[0] -= 32;
        }
        //年龄+10
        (*(s + i)).age += 10;
        printf("%s %c %d
", s[i].name, (s + i)->gender, (*(s + i)).age);
    }

指针数组: 数组中的元素都是指针

 int a = 3, b = 6, c = 9;
    //int array[3] = {a, b, c};
    int *array[3] = {&a, &b, &c};
    //array[i] = *(array + i)
    
    printf("%p
", array[0]);//&a
    printf("%p
", array[1]);//&b
    printf("%p

", array[2]);//&c
  
    printf("%p
", *array);//&a
    printf("%p
", *(array + 1));//&b
    printf("%p

", *(array + 2));//&c
    
    printf("%d
", *array[0]);//a
    printf("%d
", *array[1]);//b
    printf("%d

", *array[2]);//c
    
    printf("%d
", **array);//a
    printf("%d
", **(array + 1));//b
    printf("%d

", **(array + 2));//c

指针在字符串中的使用

char string[] = "jiujing";
    printf("%s", string + 3);
    printf("%s
", string + 3);
    
    char *p = string;//数组的名字是数组的首地址
    printf("%p
", p);

如果把字符串赋给字符指针变量, 相当于把字符串的首地址赋给字符指针变量

char *p1 = "jingjing";
    printf("%s
", p1);