指针的进阶

Posted 2022-04-03 w一个菜鸟

一 .字符指针

二.数组指针，指针数组

三.数组传参 指针传参

四.函数指针

五.函数指针数组

六.指向函数指针数组的指针

下面开始本节的内容

一.字符指针

在指针的类型中有一种指针类型的字符指针

char*

int main(void)

    char ch = w;
    char* pc = &ch;
    *pc = w;
    return 0;

第二种形式

int main(void)

    char* pstr = "hello Gerald!";
    printf("%s\\n", *pstr);
    return 0;

1.这两个变量main的栈上开辟空间，ch的地址高，pc的地址低
2.第二个里面的并不是将字符串放到指针里面，而是在字符串常量区创建了这个字符串，
将这个字符串的首地址pstr指针，而且这个字符串在读区，不能修改字符串

面试题分析

#include <stdio.h>
int main()

  char arr1[] = "abcdef";
  char arr2[] = "abcdef";
  const char* p1 = "abcdef";
  const char* p2 = "abcdef";
  if (arr1 == arr2)
  
    printf("hehe\\n");
  
  else
  
    printf("haha\\n");
  

  /*if (p1 == p2)
  
    printf("hehe\\n");
  
  else
  
    printf("haha\\n");
  */
  return 0;

​因为比较的是地址，所以arr1和arr2都是将一个字符串放在了一个数组里面，所以这两个数组的首地址是不相同的​。​但是在p1和p2是指针类型，字符串是字符常量去创建好的，并且将首地址给了p1和2，所以他们的首地址是相同的。​

二.数组指针，指针数组

#include<stdio.h>
//void print1(int arr[3][5], int x, int y)
//
//  int i = 0;
//  int j = 0;
//  for (i = 0; i < x; i++)
//  
//    for (j = 0; j < y; j++)
//    
//      printf("%d ", arr[i][j]);
//    
//    printf("\\n");
//  
//
void print2(int(*p)[5], int x, int y)

  int i = 0; 
  int j = 0;

  for (i = 0; i < x; i++)
  
    for (j = 0; j < y; j++)
    
      printf("%d ", p[i][j]);
    
    printf("\\n");

  

int main()

  int arr[3][5] =  1,2,3,4,5,2,3,4,5,6,3,4,5,6,7 ;
  //print1(arr, 3, 5);   //arr 是数组名 数组名是首原属的地址
  print2(arr, 3, 5);
  return 0;

#include <stdio.h>
int main()

  int arr[10] =  1,2,3,4,5,6,7,8,9,10 ;
  int i = 0;
  int* p = arr;
  for (i = 0; i < 10; i++)
  
    printf("%d ", p[i]);
    printf("%d ", arr[i]);
    printf("%d ", *(p+i));
    printf("%d ", *(arr + i));
  
  return 0;

//指针数组是数组，用来存放指针
#include <stdio.h>
//int main()
//
//  int arr[10] =  0 ; //整形数组
//  char ch[5] =  0 ;  //字符数组
//  int* p[4];  //存放整形指针的数组，指针数组
//  char* p1[5];//存放字符指针的数组，指针数组
//  return 0;
//
int main()

  //int* p = NULL;  //p是整形指针，指向整形中的指针  可以存放整形的地址
  //char* pc = NULL;  //pc是字符指针，指向字符的指针，可以存放字符的地址
  //int arr[10] =  0 ;
  //arr  //首元素地址
  //  & arr[0]//首元素的地址
  //  & arr//数组的地址
  int arr1[] =  1,2,3,4,5 ;
  int arr2[] =  2,3,4,5,6 ;
  int arr3[] =  3,4,5,6,7 ;
  int* p[] =  arr1,arr2,arr3 ;
  int i = 0;
  for (i = 0; i < 3; i++)
  
    int j = 0;
    for (j = 0; j < 5; j++)
    
      printf("%d ", *(p[i] + j));
    
    printf("\\n");
  
  return 0;

数组指针的使用

数组本身的元素类型加元素的个数共同决定数组类型。

数组传参时会降维成指向其内部元素类型的指针，前提是我们认为所有的数组都是一维的。

数组传参时只能省略一维数组的下标（第一个方括号）的值。

三.数组传参，指针传参

数组传参
#include<stdio.h>
////void test (int arr[])
////
////void test(int arr[10])
////
//void test(int *arr)
//
//
//int main()
//
//  int arr[10] =  0 ;
//  test(arr);
//  
//
void test(int arr[3][5])

void test(int arr[][5])

void test(int arr[3][])//  这种方式错误，二维数组中行可以省略，但是列不可以省略

int main()

  int arr[3][5] =  0 ;
  test(arr);
  test1(arr);
  test2(arr);
  return 0;

#include  <stdio.h>  //指针传参
void print(int *p,int sz)

int i=0;
for(i=0;i<sz;i++)

printf("%d\\n",*(p+i));


int main()

int arr[10] =1,2,3,4,5,6,7,8,9; 
int *p=arr;
int sz=sizeof(arr)/sizeof(arr[0]);//一级指针p，传给函数 
print(p,sz);
return 0;

四.函数指针

函数指针--指向函数的指针--存放函数地址的一个指针

函数指针
#include<stdio.h>
int Add(int x,int y)

  int z=0;
  z=x+y;
  return z;
  
int main()

  int a=10;
  int b=20;
  int arr[10]=0;
  //&arr;
  //arr;
  //Add(a,b);
  //printf("%d\\n",Add(a,b));
  //&函数名和函数名都是函数的地址
  printf("%p\\n",&Add);
  printf("%p\\n",Add); 
  return 0;
 

五.函数指针数组

函数指针数组，顾名思义，它是一个数组，这个数组里的元素是函数指针类型。

int (*pfun[10])();

pfun先和[]结合表示为一个数组，然后在和*结合，意为指针数组，最后与()结合，表示为一个数组，数组的元素是指向函数的指针。

#include <stdio.h>
#include <Windows.h>
#include <stdlib.h>
void menu()

 printf("*****************************\\n");
 printf("***  1. add      2. sub  ****\\n");
 printf("***  3. mul      4. div  ****\\n");
 printf("***              0. exit ****\\n");
 printf("*****************************\\n");
 printf("Please Enter:");



int add(int x, int y)

 return x + y;


int sub(int x, int y)

 return x - y;


int mul(int x, int y)

 return x * y;


int div_(int x, int y)

 if (y == 0)
  exit(-1);
 return x / y;



int main(void)

 int x;
 int y;
 int input = -1;
 int ret = 0;
 int (*pfun[5])(int x, int y) =  0, add, sub, mul, div_ ;

 while (input)
 
  menu();
  scanf("%d", &input);

  switch (input)
  
  case 0:
   printf("ByeBye!\\n");
   break;
  case 1:
   printf("Please Enter Numbers:");
   scanf("%d%d", &x, &y);
   ret = (*pfun[1])(x, y);
   break;
  case 2:
   printf("Please Enter Numbers:");
   scanf("%d%d", &x, &y);
   ret = (*pfun[2])(x, y);
   break;
  case 3:
   printf("Please Enter Numbers:");
   scanf("%d%d", &x, &y);
   ret = (*pfun[3])(x, y);
   break;
  case 4:
   printf("Please Enter Numbers:");
   scanf("%d%d", &x, &y);
   ret = (*pfun[4])(x, y);
   break;
  default:
   printf("ERROR!\\n");
   break;

  
  if (input == 0)
   break;
  printf("Result -> %d\\n", ret);
 
    
    system("pause");
    return 0;

六.指向函数指针数组的指针

指向函数指针数组的指针是一个指针，指针指向一个数组，数组的元素都是函数指针。

void test(const char* str)

    printf("%s\\n", str);


int main(void)

    //函数指针pfun
    void (*pfun)(const char*) = test;
    //函数指针的数组pfunArr
    void (*pfunArr[5])(const char* str);
    pfunArr[0] = test;
    //指向函数指针数组pfunArr的指针ppfunArr
    void (*(*ppfunArr)[5])(const char*) = &pfunArr;
    return 0;

本节完