C语言指针完整总结！！！

目录

1.指针介绍

1.简介：

2.指针操作符

&-取地址操作符

*-解引⽤操作符

3.指针变量的大小

4.指针类型的意义

5.const修饰指针

6.野指针

1.野指针成因

2.规避野指针的方法

7.assert断言

8.传值调用与传址调用

2.指针与数组之间的联系

1.数组名

2.数组使用的指针方式

3.指针模拟二维数组

4.冒泡排序

5.二级指针与指针数组

3.数组指针与函数指针

1.数组指针

2.函数指针

3.函数指针数组

4.转移表

4.qsort回调函数

1.使⽤qsort函数排序整型数据

2.使⽤qsort排序结构数据

3.qsort函数的模拟实现

5.strlen与sizeof的对比

6.结语

---

1.指针介绍

1.简介：

C语⾔中给地址起 了新的名字叫：指针。

一个内存单元是一字节

内存单元的编号 == 地址 == 指针

在x86的环境中，一共有32根地址总线，即32个比特位。一个字节有八个比特位，而⼀个比特位可以存储⼀个2进制的位1或者0，因此32根地址线，就能表示2^32种含 义，每⼀种含义都代表⼀个地址，如果一个地址就是一个内存单元（一字节），那么这2^32种情况一共就是4GB，也就是很多电脑的运存。而要把这2^32个比特位存起来作为地址，则需要4个字节的内存。相同的，x64环境下，则需要8个字节的内存.

2.指针操作符

&-取地址操作符

例如：&a取出的是a所占4个字节中地址较小的字节的地址。

只要知道了小字节的地址，往后找即可找到目标变量的所有字节地址

*-解引⽤操作符

与取地址操作符作用相反，解引⽤操作符是把地址解引用为变量指向的内容

int a = 10;
int * pa = &a

在以上代码中，*说明了pa是一个指针，而int说明了pa指向的内容数据类型是int型的。

当然指针也有数据类型，上面例子的pa指针就是int*型的。

3.指针变量的大小

32位机器假设有32根地址总线，每根地址线出来的电信号转换成数字信号后 是1或者0，那我们把32根地址线产⽣的2进制序列当做⼀个地址，那么⼀个地址就是32个bit位，需要4 个字节才能存储。 如果指针变量是⽤来存放地址的，那么指针变的⼤⼩就得是4个字节的空间才可以。 同理64位机器，假设有64根地址线，⼀个地址就是64个⼆进制位组成的⼆进制序列，存储起来就需要 8个字节的空间，指针变的⼤⼩就是8个字节。

32位平台下地址是32个bit位，指针变量⼤⼩是4个字节 • 64位平台下地址是64个bit位，指针变量大小是8个字节 • 注意指针变量的⼤⼩和类型是⽆关的，只要指针类型的变量，在相同的平台下，大小都是相同的。

4.指针类型的意义

另外，指针的类型决定了，对指针解引⽤的时候有多⼤的权限（⼀次能操作⼏个字节）

⽐如： char* 的指针解引⽤就只能访问⼀个字节，⽽ int* 的指针的解引⽤就能访问四个字节。

在指针+-整数中，因为指针类型不同，+-整数跳过的字节数也不同

例如：char* 类型的指针变量+1跳过1个字节， int* 类型的指针变量+1跳过了4个字节。 这就是指针变量的类型差异带来的变化。

void*指针是泛型指针，是一种无具体类型的指针，一般在不确定指向内容的数据类型的时候使用它，得知类型后强制类型转换进行解引用或者+-整数操作，不强制类型转换就无法进行以上操作。

⼀般 void* 类型的指针是使⽤在函数参数的部分，⽤来接收不同类型数据的地址，这样的设计可以 实现泛型编程的效果，使得⼀个函数来处理多种类型的数据。

5.const修饰指针

结论：const修饰指针变量的时候 • const如果放在*的左边，修饰的是指针指向的内容，保证指针指向的内容不能通过指针来改变。 但是指针变量本⾝的内容可变。 • const如果放在*的右边，修饰的是指针变量本⾝，保证了指针变量的内容不能修改，但是指针指 向的内容，可以通过指针改变。

6.野指针

1.野指针成因

指针未初始化

指针越界访问

指针指向的空间释放

2.规避野指针的方法

指针初始化

防止指针越界

指针变量不再使⽤时，及时置NULL，指针使⽤之前检查有效性

避免返回局部变量的地址

7.assert断言

下面代码在程序运⾏到这⼀⾏语句时，验证变量 p 是否等于 NULL 。如果确实不等于 NULL ，程序 继续运⾏，否则就会终⽌运⾏，并且给出报错信息提⽰。

assert(p!=NULL);

使用assert函数需要加入assert.h的头文件

8.传值调用与传址调用

传值调用是函数只需要用到变量的值，因此传参是只要把传值即可，而传址调用是把参数的地址传参，这样就能从根本上操控变量，解决了临时的局部变量出函数就被销毁的问题

2.指针与数组之间的联系

1.数组名

大家都知道，数组名是数组首元素的地址，其实它本质上就是指针，指向数组首元素。

但它有两个例外：
• sizeof(数组名)，sizeof中单独放数组名，这⾥的数组名表⽰整个数组，计算的是整个数组的⼤⼩，
单位是字节
• &数组名，这⾥的数组名表⽰整个数组，取出的是整个数组的地址（整个数组的地址和数组⾸元素
的地址是有区别的）

2.数组使用的指针方式

int arr[3][5]={0};
for(int i=0;i<3;i++)
{
    int j=0;
    for(j=0;j<5;j++)
   {
    arr[i][j]=1;
    //这里相当于是（*（arr+i）+j）

   }
}

在二维数组中，首元素指的是整个第一行的地址，进行+-操作跳过的字节数也是一整行的字节数，+i说明了跳到了第几行，解引用操作后确定了行数，+j又确定了列数，再次解引用就是具体的某行某列的具体位置。

可以理解是指针模拟二维数组的过程，下面会有讲

3.指针模拟二维数组

#include <stdio.h>
int main()
{
 int arr1[] = {1,2,3,4,5};
 int arr2[] = {2,3,4,5,6};
 int arr3[] = {3,4,5,6,7};
 //数组名是数组⾸元素的地址，类型是int*的，就可以存放在parr数组中
 int* parr[3] = {arr1, arr2, arr3};
 int i = 0;
 int j = 0;
 for(i=0; i<3; i++)
 {
 for(j=0; j<5; j++)
 {
 printf("%d ", parr[i][j]);
 }
 printf("\n");
 }

parr[i]是访问parr数组的元素，parr[i]找到的数组元素指向了整型⼀维数组，parr[i][j]就是整型⼀维数 组中的元素。与2的原理一样。

4.冒泡排序

冒泡排序的核⼼思想就是：两两相邻的元素进⾏⽐较。

void bubble_sort(int arr[], int sz)//参数接收数组元素个数
{
 int i = 0;
 for(i=0; i<sz-1; i++)
 {
 int flag = 1;//假设这⼀趟已经有序了
 int j = 0;
 for(j=0; j<sz-i-1; j++)
 {
 if(arr[j] > arr[j+1])
 {
 flag = 0;//发⽣交换就说明，⽆序
 int tmp = arr[j];
 arr[j] = arr[j+1];
 arr[j+1] = tmp;
 }
 }
 if(flag == 1)//这⼀趟没交换就说明已经有序，后续⽆序排序了
 break;
 }
}
int main()
{
 int arr[] = {3,1,7,5,8,9,0,2,4,6};
 int sz = sizeof(arr)/sizeof(arr[0]);
 bubble_sort(arr, sz);
 for(i=0; i<sz; i++)
 {
 printf("%d ", arr[i]);
 }
 return 0;
}

以上是优化后的完整代码

5.二级指针与指针数组

*ppa 通过对ppa中的地址进⾏解引⽤，这样找到的是 pa ， *ppa 其实访问的就是 pa .

int b = 20;
*ppa = &b;//等价于 pa = &b；

**ppa 先通过 *ppa 找到 pa ,然后对 pa 进⾏解引⽤操作： *pa ，那找到的是 a .

**ppa = 30;
//等价于*pa = 30;
//等价于a = 30;

以下是指针数组：

本质上是数组，指向的每一个元素都是int*型的，即存放指针的数组，故也有char*arr[]等等

3.数组指针与函数指针

1.数组指针

与指针数组不同，数组指针是指向一整个数组的指针

例如它：

int (*p2)[10];

p先和*结合，说明p是⼀个指针变量变量，然后指着指向的是⼀个⼤⼩为10个整型的数组。所以 p是⼀个指针，指向⼀个数组，叫 数组指针。 这⾥要注意：[]的优先级要⾼于*号的，所以必须加上（）来保证p先和*结合。

2.函数指针

函数名就是函数的地址，当然也可以通过 &函数名 的方式获得函数的地址。

举例：

void test()
{
 printf("hehe\n");
}
void (*pf1)() = &test;
void (*pf2)()= test;
int Add(int x, int y)
{
 return x+y;
}
int(*pf3)(int, int) = Add;
int(*pf3)(int x, int y) = &Add;/

3.函数指针数组

把函数的地址存到⼀个数组中，那这个数组就叫函数指针数组

//例如：
int (*p[3])(int,int)={func1,func2,func3}

说明了指向的函数有两个int的参数，返回值为int

4.转移表

#include <stdio.h>
int add(int a, int b)
{
 return a + b;
}
int sub(int a, int b)
{
 return a - b;
}
int mul(int a, int b)
{
 return a*b;
}
int div(int a, int b)
{
 return a / b;
}
int main()
{
 int x, y;
 int input = 1;
 int ret = 0;
 int(*p[5])(int x, int y) = { 0, add, sub, mul, div }; //转移表
 do
   {
   printf("*************************\n");
   printf(" 1:add 2:sub \n");
   printf(" 3:mul 4:div \n");
   printf(" 0:exit \n");
   printf("*************************\n");
   printf( "请选择：" );
   scanf("%d", &input);
   if ((input <= 4 && input >= 1))
   {
     printf( "输⼊操作数：" );
     scanf( "%d %d", &x, &y);
     ret = (*p[input])(x, y);
     printf( "ret = %d\n", ret);
   }
  else if(input == 0)
    {
    printf("退出计算器\n");
    }
    else
    {
    printf( "输⼊有误\n" ); 
    }
   }while (input);
 return 0;
}

4.qsort回调函数

1.使⽤qsort函数排序整型数据

#include <stdio.h>
//qosrt函数的使⽤者得实现⼀个⽐较函数
int int_cmp(const void * p1, const void * p2)
{
 return (*( int *)p1 - *(int *) p2);
}
int main()
{
 int arr[] = { 1, 3, 5, 7, 9, 2, 4, 6, 8, 0 };
 int i = 0;
 
 qsort(arr, sizeof(arr) / sizeof(arr[0]), sizeof (int), int_cmp);
 for (i = 0; i< sizeof(arr) / sizeof(arr[0]); i++)
 {
 printf( "%d ", arr[i]);
 }
 printf("\n");
 return 0;
}

2.使⽤qsort排序结构数据

struct Stu //学⽣
{
    char name[20];//名字
    int age;//年龄
};

//假设按照年龄来⽐较
int cmp_stu_by_age(const void* e1, const void* e2)
{
    return ((struct Stu*)e1)->age - ((struct Stu*)e2)->age;
}

//strcmp - 是库函数，是专⻔⽤来⽐较两个字符串的⼤⼩的
//假设按照名字来⽐较

int cmp_stu_by_name(const void* e1, const void* e2)
{
    return strcmp(((struct Stu*)e1)->name, ((struct Stu*)e2)->name);
}
//按照年龄来排序

void test2()
{
    struct Stu s[] = { {"zhangsan", 20}, {"lisi", 30}, {"wangwu", 15} };
    int sz = sizeof(s) / sizeof(s[0]);
    qsort(s, sz, sizeof(s[0]), cmp_stu_by_age);
}
//按照名字来排序

void test3()
{
    struct Stu s[] = { {"zhangsan", 20}, {"lisi", 30}, {"wangwu", 15} };
    int sz = sizeof(s) / sizeof(s[0]);
    qsort(s, sz, sizeof(s[0]), cmp_stu_by_name);
}


int main()
{
    test2();
    test3();
    return 0;
}

3.qsort函数的模拟实现

使⽤回调函数，模拟实现qsort（采⽤冒泡的⽅式）。

#include <stdio.h>

int int_cmp(const void * p1, const void * p2)
{
 return (*( int *)p1 - *(int *) p2);
}


void _swap(void *p1, void * p2, int size)
{
 int i = 0;
   for (i = 0; i< size; i++)
   {
     char tmp = *((char *)p1 + i);
     *(( char *)p1 + i) = *((char *) p2 + i);
     *(( char *)p2 + i) = tmp;
   }
}


void bubble(void *base, int count , int size, int(*cmp )(void *, void *))
{
 int i = 0;
 int j = 0;
    for (i = 0; i< count - 1; i++)
    {
       for (j = 0; j<count-i-1; j++)
       {
         if (cmp ((char *) base + j*size , (char *)base + (j + 1)*size) > 0)
         {  
           _swap(( char *)base + j*size, (char *)base + (j + 1)*size, size);
         }
       }
    }
}


int main()
{
    int arr[] = { 1, 3, 5, 7, 9, 2, 4, 6, 8, 0 };
    int i = 0;
    bubble(arr, sizeof(arr) / sizeof(arr[0]), sizeof (int), int_cmp);
     for (i = 0; i< sizeof(arr) / sizeof(arr[0]); i++)
     {
        printf( "%d ", arr[i]);
     }
     printf("\n");
      return 0;
}

5.strlen与sizeof的对比

sizeof 在学习操作符的时候，我们学习了 sizeof ， sizeof 计算变量所占内存内存空间⼤⼩的，单位是 字节，如果操作数是类型的话，计算的是使⽤类型创建的变量所占内存空间的⼤⼩。 sizeof 只关注占⽤内存空间的⼤⼩，不在乎内存中存放什么数据。

strlen 是C语⾔库函数，功能是求字符串⻓度

6.结语

指针的总结就到这里，指针是学好c语言的核心，还有很多大大小小的知识点和细节值得大家不断的学习，修炼好指针的内功！！！