C语言指针进阶2

飞奔的炮台

qsort函数的使用

使用qsort函数
int cmp(const char* e1, const char* e2)
{
  return *((int*)e2) - (*(int*)e1);
}
void print(int* arr,int sz)
{
  int i = 0;
  for (i = 0;i < sz; i++)
  {
  printf("%d ", arr[i]);
  }
}
int main()
{
  int arr[] = { 1,2,3,4,5,6,7,8,9 };
  int sz = sizeof(arr)/sizeof(arr[0]);
  qsort(arr,  sz,    sizeof(arr[0]),   cmp);//cmp表示另外一个函数
    数组  元素个数  单个元素的大小   比较数组中相邻连个元素的大小
  print(arr,sz);
  return 0;
}

qsort函数的制造

struct stu
{
  char name[20];
  int number;
};
//比较int类型
int arrint_cmp(const void* e1, const void* e2)
{
  return *(int*)e2 - *(int*)e1;
}
//比较结构体类型中的字符串
int struct_strcmp(const void* e1, const void* e2)
{
  return strcmp(((struct stu*)e1)->name, ((struct stu*)e2)->name);
  //这里形参时整个分支，但是在比较的时候，只用其中一个分支的某一个变量
  //这利用的就是name，以为是一个字符串，所以只比较首个字符的大小
}
//比较结构体中的数字
int struct_intcmp(const void* e1, const void* e2)
{
  return ((struct stu*)e1)->number - ((struct stu*)e2)->number;
}
//交换函数
void swap(char* a,char*b, int width)
{
  int i = 0;
  for (i = 0;i < width;i++)
  {
  char tmp = *a;
  *a = *b;
  *b = tmp;
  a++;
  b++;
  }
}
//写的qsort
void my_qsort(void* arr,int sz,int width,int(*p)(void*,void*))
{
  int i = 0, j = 0;
  for (i = 0;i < sz - 1;i++)//循环次数
  {
  for (j = 0;j < sz - 1 - i;j++)//进行的各个交换
  {
    if ((*p)(((char*)arr+j*width),((char*)arr + (j+1) * width)) > 0)
    //在这里只是判断这个返回值的大小，里面的函数传结构体的时候，将结构体中的一整个分支都传过去
    {
    //在比较收个字符大小之后，再将两个分支传递给交换函数，将整个分支进行交换
    swap(((char*)arr + j * width), ((char*)arr + (j+1) * width),width);
    }
  }
  }
}
//打印函数
void print(int* arr, int sz)
{
  int i = 0;
  for (i = 0;i < sz; i++)
  {
  printf("%d ", arr[i]);
  }
}
//按结构体中的两种不同类别经i性能排序
void struct_str_text()
{
  struct stu s[3] = { {"zhangsan",20},
      {"lisi",19},
      {"wangwu",18} };
  int sz1 = sizeof(s) / sizeof(s[0]);
  //按字符串排序
  //my_qsort(s, sz1, sizeof(s[0]), struct_strcmp);
  //按数字排序
  my_qsort(s, sz1, sizeof(s[0]), struct_intcmp);
  //printf("%s ", s.number);
  
}
//按数组进行排序
void arr_int_text()
{
  int arr[] = { 1,2,3,4,5,6,7,8,9 };
  
  int sz = sizeof(arr) / sizeof(arr[0]);
  my_qsort(arr, sz, sizeof(arr[0]), arrint_cmp);//cmp表示另外一个函数
  //   数组  元素个数  单个元素的大小   比较数组中相邻连个元素的大小
  print(arr, sz);
  
}
//主函数调用
int main()
{
  //arr_int_text();
  struct_str_text();
  return 0;
}

指针深度理解

int main()
{
  /*int arr[] = { 1,2,3,4,5,6,7 };*/
  printf("%d\n", sizeof(arr));// 28 这里的arr是整个数组的地址，计算的也是整个数组中所有元素的地址字节总和,int类型4*个数7==28
  printf("%d\n", sizeof(arr+0));//4 这里代表的是首元素的地址+0还是首元素的地址，地址是4字节
  printf("%d\n", sizeof(*arr));// 4 这里还是首元素的地址，取内容得到1由于是int类型得到4
  printf("%d\n", sizeof(arr[1]));//4 同上，但是得到的是第二个元素的值
  printf("%d\n", sizeof(arr+1));//4 
  printf("%d\n", sizeof(&arr));//4 这里是整个元素的地址，无论是谁都是4/8
  printf("%d\n", sizeof(&arr+1));//4 同上，但是跳过了整个数组
  printf("%d\n", sizeof(*&arr));//28，可以想象成两个符号相抵消，int类型4*个数7==28
  printf("%d\n", sizeof(&arr[0]));//4 
  printf("%d\n", sizeof(&arr[0]+1));//第一个元素的地址，跳过类一个数组
  char arr1[] = { 'a','b','c','d' };
  printf("%d ", sizeof(arr1));//4 这里是
  上下两种意思不同，上面的是个数乘以类型字节
  下面的意思是地址
  printf("%d ", sizeof(arr1+1));//3////这的意思是首元素地址，+1跳还是地址
  printf("%d ", sizeof(*arr1));//1
  printf("%d ", sizeof(arr1[1]));//1
  printf("%d ", sizeof(&arr1));//4
  printf("%d ", sizeof(&arr1 + 1));//4
  printf("%d ", sizeof(&arr1[0] + 1));//4
  char arr1[] = { 'a','b','c','d' };
  //strlen函数是接受的一个地址
  printf("%d ", strlen(arr1));//sui
  printf("%d ", strlen(arr1 + 1));// sui
  printf("%d ", strlen(*arr1));//err
  printf("%d ", strlen(arr1[1]));//err
  printf("%d ", strlen(&arr1));//sui
  printf("%d ", strlen(&arr1 + 1));//sui
  printf("%d ", strlen(&arr1[0] + 1));//sui
  char arr1[] = "abcd";
  //&arr1就是整个地址，跳的话也是整个地址
  //strlen函数是接受的一个地址
  printf("%d ", strlen(arr1));//4
  printf("%d ", strlen(arr1 + 1));//3
  //printf("%d ", strlen(*arr1));//err
  //printf("%d ", strlen(arr1[1]));//err
  printf("%d ", strlen(&arr1));//4
  printf("%d ", strlen(&arr1 + 1));//sui
  printf("%d ", strlen(&arr1[0] + 1));//3
  /*char* p="abcd";char* p="abcd";*/
  printf("%d ", sizeof(p));//4 这里是地址
  printf("%d ", sizeof(p + 1));//4
  printf("%d ", sizeof(*p));//1//这里是首元素的地址，取内容是a，类型是char
  printf("%d ", sizeof(p[1]));//1
  printf("%d ", sizeof(&p));//4
  printf("%d ", sizeof(&p + 1));//4
  printf("%d ", sizeof(&p[0] + 1));//4
  char* p = "abcd";
  printf("%d\n", strlen(p));//4
  printf("%d\n", strlen(p+1));//3
  //printf("%d\n", strlen(*p));//err
  //printf("%d\n", strlen(p[1]));//err
  printf("%d\n", strlen(&p));//sui
  printf("%d\n", strlen(&p+1));//sui
  printf("%d\n", strlen(&p[0]+1));//3
  int a[3][4] = { 0 };
  printf("%d\n", sizeof(a));//3*4*4
  printf("%d\n", sizeof(a[0][0]));//4
  printf("%d\n", sizeof(a[0]));//16//二维数组第一个元素，是整个第一个二级数组，sizeof(int)*列
  printf("%d\n", sizeof(a[0]+1));//4,地址
  printf("%d\n", sizeof(*(a[0] + 1)));//4，类型大小
  printf("%d\n", sizeof(a + 1));//4，地址
  printf("%d\n", sizeof(*(a + 1)));//16//这里的a是二维数组首元素地址即整个二级数组的地址在取内容
  printf("%d\n", sizeof(&a[0]+1));//4
  printf("%d\n", sizeof(*(&a[0] + 1)));//16
  printf("%d\n", sizeof(*a));//16
  printf("%d\n", sizeof(a[3]));//16
  //任何一个表达式都有两个表达式1、值属性2、类型属性
  // sizeof(a[3])这里是用类型属性计算出来的
  //sizeof()括号里面的是不会真正去计算的
  return 0;
}

总结
：再求这种题的时候只有两种特殊情况
1、sizeof(arr)这里求的是整个元素占多少字节
2、&arr这里求的是整个数组的地址+1跳的也是真个数组

强制类型转换时的指针

struct text
{
  char name[10];
}*p;
int main()
{
  printf("%d\n", p);//
  printf("%d\n", p + 0x1);//p的类型是指针+1跳过了一整个数组
  printf("%d\n", (unsigned int)p + 0x1);//转换成了unsigned int 加1就是+1
  printf("%d\n", (unsigned int*)p + 0x1);
  //这里转换成了unsigned int*+1就是跳过了unsigned int*的步长
  return 0;
}

int main()
{
  //这里是小端存储（小端的一边数字权重比较小）
  //所以我们按左端是小端而右边是大端
  
  int arr[] = { 1,2,3,4 };//00 00 00 00 
  int* prt = (int*)(&arr + 1);
  int* prt1 = (int*)((int)arr + 1);
  printf("%x\n",prt[-1]);//4   //指针先以整个数组的大小进行跳跃，跳到最后，再转换成int*类型-1向后跳跃4个字节，在以16进制进行读取
  //00 00 00 01|00 00 00 02|00 00 00 03|00 00 00 04|先跳到最后面在转换成int*-1向后移动1个int*的步数，在往后面读取
  
  //地址里本来就是16进制进行储存的，打印的话格式按照16进制才能打印出来
  printf("%x\n",prt1[0]);
  //2 00 0000 这里先把数组首元素地址转换成int类型在+1就是一个字节，再转换成int*类型向后读取4个字节里面的内容，那个2就在读取的最后一个字节里面
  //01 00 00 00|02 00 00 00|03 00 00 00|04 00 00 00|
  //  |00 00 00 02|加一就像后面移动了1位读取后的结果，
  //在字节内中读取的时候是从左向右即从地址小的地方开始读取 
  //在地址里面，每一次以int类型+1，就相当于跳跃一个char*类型
  //因为每一个地址对应一个字节
  //1个字节8位，每四位也就是总共15是一个字节 00 ，两位中的其中一位
  return 0;
}

int main()
{
  int a[5][5];
  int(*p)[4];
  p = a;
  printf("%p\n%d\n", &p[4][2] - &a[4][2], &p[4][2] - &a[4][2]);
  //这里的的负数存在内存中的时候，是存的-4，读取的时候是-4但是在以16进制打印的是偶
  printf("%d\n", sizeof(&p[4][2] - &a[4][2]));
  return 0;
}

int main()
{
  int arr[2][5] = { 1,2,3,4,5,6,7,8,9,10 };
  int* ptr1 = (int*)(&arr + 1);
 //整个数组的地址+1跳过整个数组，再转换成int*，-1后退一个int类型即4个字节就是10
  int* ptr2 = (int*)(*(arr + 1));
 //首元素的地址+1跳过一个二级数组，换成int*-1，后退一个int类型即4个字节就是5
  printf("%d %d", *(ptr1 - 1), *(ptr2 - 1));
  return 0;
}

数据结构的知识补充

int main()
{
  char a = 128;
  printf("%u", a);
  printf("%d", a);
  printf("%p", a);
  //1、内存里面存的是什么
  //2、打印的时候按什么格式打印的
  
  //村进入内存的时候是10000000
  //以16进制打印
  //在以16进制打印的时候不会再转换成原码，而是直接以补码形式打印
  
  //有符号形式打印
  //11111111 11111111 11111111 10000000
  //10000000 00000000 00000000 01111111
  //10000000 00000000 00000000 10000000
  //无符号形式打印
  //00000000 00000000 00000000 10000000
  //11111111 11111111 11111111 01111111
  //11111111 11111111 11111111 10000000
  return 0;
}

int main()
{
  int a = -128;
  printf("%u\n", a);
  //10000000 00000000 00000000 10000000
  //11111111 11111111 11111111 01111111
  //11111111 11111111 11111111 10000000（存进去）(补码)
  //以无符号形式打印，会直接打印补码（对于无符号整形就是正数），不会再转化成原码就是补码
  printf("%d\n", a);
  //10000000 00000000 00000000 10000000
  //11111111 11111111 11111111 01111111
  //11111111 11111111 11111111 10000000（存进去）(补码)
  //10000000 00000000 00000000 01111111
  //10000000 00000000 00000000 10000000(原码打印)-128
  printf("%p\n", a);
  //00000000 00000000 00000000 10000000
  //11111111 11111111 11111111 01111111
  //11111111 11111111 11111111 10000000（存进去）(补码)
  //直接补码打印
  return 0;
}

指针指向多个字符串的数组

int main()
{
  char* arr[] = { "abc","at","bgv" };//本句的意思是arr是一个数组，里面存放的是char*类型的元素
  //所以数组里面存放的都是三个元素的首地址，arr可以看作成二级数组
  
  char** p = arr;
  //arr是数组首元素的地址，将数组首元素的地址(首元素存放的还是一个地址，关于字符串的),存放到p里面，所以p就是char**
  //由此可以看出，可以根据指针的类型判断出所指向的元素的类型
  p++;//p是首元素的地址,p++，就是首元素地址+1
  printf("%s", *p);//p取内容，第二个元素的地址取内容，就是第二个字符串
  return 0;
}

1、指针在定义的时候，一共有几颗星，解引用（几-1）次，就可以得到内容
2、在指针定义的过程中,完全可以在脑海中补引入第三个盒子，相当于，把所要只想的东西提出来（掰开一般出来），一半就是另一半

数组指针和指针

int main()
{
  int* p = NULL;
  int arr[10] = { 0 };
  return 0;
}

A.p=arr
这里的arr是一个数组首元素的地址，类型是int*所以p可以指向
B.int(*ptr)[10]=&arr
&arr是整个数组的地址，指向整个数组的地址的指针是必须是一个数组指针，所以符合
C.p=&arr[0]
同A
D.p=&arr
这里的p只是一个int*类型的指针，不是数组指针所以错误