Day16-指针2

Python资料网推荐Day16-指针2这篇文章给大家，欢迎收藏Python资料网享受知识的乐趣

数组指针与指针数组

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

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

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

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

数组指针

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

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

  • 案例：一维数组指针

    /*
    数组指针：指向数组的指针
    */
    #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   0

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

版权声明：本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若内容造成侵权/违法违规/事实不符，请联系邮箱：jacktools123@163.com进行投诉反馈，一经查实，立即删除！