Day16-指针2

数组指针与指针数组

变量指针：指向变量的地址。

数组指针：指向数组的地址。

指针变量：存放其他变量地址的变量。

指针数组：存放数组元素指针的变量。

数组指针

• 概念：数组指针是指向数组的指针。
• 特点：
  • 先有数组，后有指针。
  • 它指向的是一个完整的数组。
• 示例：一维数组指针
  • 语法：

    数据类型（*指针变量）[容量]；

  • 案例：一维数组指针

    /*
    数组指针：指向数组的指针
    */
    #include <stdio.h>int main()
    {// 一维数组指针//  先有数组，再有指针int arr[3] = {100, 200, 300};// 获取数组元素个数int len = sizeof arr / sizeof arr[0];// 定义一个数组指针，指向arr数组// 数组指针的语法：数据类型（*指针变量名）[数据容量]int(*p)[3] = &arr; // 此时p不是指向数组中arr的第一个元素，而是指向arr这个数组本身printf("%p\n", p);// p++;   此时p++会跳出整个数组// printf("%p\n", p);printf("%d\n", (*p)[2]); // 300// 遍历for (int i = 0; i < len; i++){printf("%d\n", (*p)[i]);}printf("\n");// int *p = &arr[0] | arr;  这种写法，代表p指向的不是数组本身，是数组中的第一个元素
    }

  • 二维数组指针
    • 语法：

      数据类型(*指针变量名)[容量];

    • 指针和数组中符号优先级： （） >  [ ]  >  *  
    • 案例：

/*二维数组指针案例：
*/
#include <stdio.h>int main()
{// 数组指针：先有数组，再有指针int arr[][3] = {{100, 200, 300}, {1000, 2000, 3000}, {10, 20, 30}};// 创建一个数组指针，指向二维数组// int(*p)[3] = &arr; // p[0]  --> {100,200,300},p[1] -->{1000,2000,3000},也就是说：p[0] = 元素100的首地址，p[1] = 元素1000的首地址int(*p)[3] = arr; // arr等价于&arr[0],p[0] = 元素100的首地址// 获取元素100？printf("100-%d\n", (*p)[0]); // arr[0][0]// 获取元素2000？printf("2000-%d,%d,%d\n", *(*(p + 1) + 1), *(p[1] + 1), p[1][1]); // arr[i][j] ===> *(*(p+i)+j) ==> *(p[i]+j) ==>p[i][j]return 0;}

指针数组

• 概念：指针数组是一个数组，数组中的每一个元素都是一个指针。
• 特点：
  • 先有“指针”，后有“数组”
  • 指针数组的本质是一个数组，只是数组中的元素类型为指针。
• 语法：

数据类型 *数组名 [容量]；

• 案例：

/*
指针数组
*/
#include <stdio.h>int main()
{// 定义三个变量int a = 10, b = 20, c = 30;// 定义指针数组，指针数组用来存放指针（变量或者常量的内存地址）int *arr[3] = {&a, &b, &c};// 获取数组大小int len = sizeof arr / sizeof arr[0];// 遍历数组for (int i = 0; i < len; i++){printf("%3d", *(arr[i])); // 输出每个指针所指向的值，需要解引用}printf("\n");return 0;
}

• 建议：我们一般使用指针数组处理字符串

char [][10] = {"hello","majie"
}

字符串指针

字符串实现

在C语言中，表示一个字符串有以下两种方式

         1.用字符数组存放一个字符串

         2.用字符指针指向一个字符串

/*字符串的两种实现方式
*/
#include <stdio.h>
// 使用字符数组实现
void fun()
{// 定义伪字符串char str[] = "I Love You!";printf("%s\n", str);
}// 使用字符指针实现
void fun1()
{char *str = "I Love You!";printf("%s\n", str);
}int main()
{fun();fun1();return 0;
}

注意:字符数组和字符指针变量都能实现字符串的存储与运算。

字符数组和字符指针的联系

• 字符数组由元素组成，每个元素中存放一个字符，而字符指针变量中存放的是地址，也能作为函数参数。
•  只能对字符数组中的各个元素赋值，而不能用赋值语句对整个字符数组赋值。
• 字符数组名虽然代表地址，但数组名的值不能改变。因为数组名是常量。
• 对于字符串中字符的存取，可以用下标法，也可以用指针法。

案例：

/*字符数组和字符指针的联系
*/
#include <stdio.h>int main()
{// 使用两种方式定义字符串char str1[] = "你好，马杰克!";char *str2 = "你好，马杰克!";// 测试赋值// str1 = "你好,龙1"; 不能对字符数组整体赋值，如果要赋值，请使用strcpy()str2 = "你好,龙2";// 打印输出printf("%s\n%s\n", str1, str2);char a[] = "I Love You!";char *b = "I love You!";// 下标法和指针法访问字符串printf("%c\n%c\n", a[3], *(b + 3)); // 0   0return 0;
}

字符串指针作为形式参数

• 实参与形参都可以是字符数组
• 实参用字符数组，形参用字符指针（在函数内部不能对字符串中的字符做修改）

test5(char *arr,int len)
{arr[2] = 'A'; // 错误，字符串常量一旦创建，就不能被更改
}main()
{char arr[] = "abc";  //字符串常量，常量是不可修改的test(arr,3);
}

• 实参和形参都是指针变量（在函数内部不能对字符串中的字符做修改）

test(char *arr,int len)
{arr[2] = 'A'; // 错误
}
main()
{char arr[] = "abc";char *p = arr;  // &arr[0]test(p,3);
}

• 实参是指针类型，形参是字符数组

1

注意：

        1.字符数组在创建的时候，会在内存中开辟内存空间，内存空间可以存放字符数据；字符指针在创建的时候，需要依赖字符数组，字符指针在内存中开辟的内存空间中，存放的是数组元素的内存地址。字符指针的创建依赖字符数组，字符数组可以独立存在，而字符指针不能独立存在。

        2.字符数组可以初始化，但是不能赋值；字符指针可以初始化，也可以赋值。

// 字符数组
char str1[11] = "I love You!";str1 ="Home";//错误str1[]=“home”;// 错误// 字符指针
char *str2 ="I love You!";str2="home";// 正确

案例2：

/*给定一个字符串，截取start到end之间字符串，含头不含尾
*/
#include <stdio.h>
// 字符串截取函数
int str_split(char *str, int start, int end, char *temp)
{// 定义一个循环变量int i = 0, k = 0;// 定义一个字符指针，用来接收str中截取到的字符串// char *temp ;// 循环遍历每一个字符while (str[i] != '\0'){if (i >= start && i < end){temp[k] = str[i];k++;}i++;}temp[k] = '\0';// 更新str中的数据str = temp;return k;
}
int main()
{char *str = "abcdefg";char temp[100];int len = str_split(str, 2, 5, temp);printf("str=%s,len=%d\n", temp, len);return 0;
}

函数指针与指针函数

函数指针

• 定义：函数指针本质是指针，它是函数的指针（定义一个指针变量 ，变量中存储了函数的地址）
• 函数指针存在的意义：

                1.让函数多了一种调用方式

                2.函数指针作为形参，可以形式调用（回调函数）

• 定义格式：

  返回值类型 （*变量名）（形式参数列表）；

  举例：

  int (*p) (int a,int b);

• 函数指针的初始化
  
  1.定义同时赋值

  //得先有函数，才能定义函数的指针
  int fun(int a,int b){......}//定义函数指针并给它赋值
  int (*p) (int a,int b) = fun; // fun不能跟()

  2.先定义后赋值

  //得先有函数，才能定义这个函数的指针
  float int fun(int a,double b,char c){....}//定义函数指针
  float (*p) (int a,double b,char c);
  //赋值
  p = fun;

总结：

        1.函数指针指向的函数要和函数指针定义的返回值类型，形参列表对应，否则编译报错。

        2.函数指针是指针，但不能指针运算，如p++等，没有实际意义。

        3.函数指针作为形参，可以形成回调（后面说）。

        4.函数指针作为形参，函数调用时的实参只能是与之对应的函数名，不能带小括号。

        5.函数指针的形参列表中的变量名可以省略。

案例：
 

/*函数指针：指向函数的指针变量就是函数指针需求：求a,b两个数的最大值
*/
#include <stdio.h>
int max(int a, int b)
{if (a > b){return a;}return b;
}int main()
{int a = 3, b = 2, c;// 普通函数调用c = max(3, 2);printf("%d,%d两个数中的最大值是: %d\n", a, b, c);// 通过指针变量访问它指向的函数// 创建指针并初始化int (*p)(int a, int b) = max;// 调用函数指针c = p(a, b);printf("%d,%d两个数中的最大值是: %d\n", a, b, c);// 调用函数指针c = (*p)(a, b);printf("%d,%d两个数中的最大值是: %d\n", a, b, c);return 0;
}

指针函数

• 定义：本质是函数，这个函数的返回值是指针，这个函数称为指针函数。
• 定义格式：

  指针类型 函数名 (形参列表)
  {函数体;return 指针变量;
  }

  举例：
   

  int *get(int a)
  {int *b = &a;//return &a; // 编译报警告return b;
  }

  • 注意：
    
    在函数中不要直接返回一个局部变量的地址，因为函数调用完毕后，局部变量会被回收，使得返回的地址就不明确，此时返回的指针就是野指针。
    
    解决方案：
    
                    如果非要访问，可以给这个局部变量添加 static ,可以延长它的生命周期，从而避免野指针（尽量少用，因为存在内存泄漏）。

                案例：
                

/*指针函数：函数的返回值是指针类型需求：有若干个学生的成绩(每个学生有4门课程)要求在用户输入学生序号以后:能输出该学生的全部成绩。用指针函数来实现。
*/
#include <stdio.h>// 定义一个函数，传入学生的序号，返回这个学生的所有课程成绩
float *search(float (*p)[4], int n)
{// 定义一个指针，用来接收查询到的某个学生的所有课程float *pt;pt = *(p + n);return pt;
}int main()
{// 准备所有学生的成绩float score[][4] = {{60, 70, 80, 90},{56, 66, 76, 76},{35, 68, 90, 37}};int i, m;float *p;printf("请输入学生序号(0-2): \n");scanf("%d", &m);printf("第%d个学生的成绩: \n", m);p = search(score, m); // 函数返回值为行的首地址// 遍历for (i = 0; i < 4; i++){printf("%5.2f\t", p[i]);}printf("\n");return 0;
}