1.指针变量

指针变量是用来存储地址值的变量

<code>#include<stdio.h>

int main()

{

    int a = 10;

    int* pa = &a;//1.这里*表示pa是指针变量

                 //2.int表示pa指向的变量a的类型是int 

    return 0;    

}

指针变量也是一种变量，这种变量可以用来存放地址的，存放在指针变量中的值都可以理解为地址。

那么我们应该如何理解指针的类型呢？

int a = 10;

int* pa = &a;

在这个代码中，*指的是pa是指针变量，而前面的int是在说明pa指向的是整型（int）类型的对象。

2.解引用操作符

解引用操作符（*），也叫做间接访问操作符。

#include<stdio.h>

int main()

{

    int a = 100;

    int* pa = &a;

    *pa = 0;

 

    return 0;

}

在上述的代码中我们运用了解引用操作符，*pa的意思就是通过pa中存放的地址,找到指向的空间，*pa其实就是a变量了；所以*pa=0，这个操作符是把a改成了0；

3.指针变量的大小

1.指针变量的大小只与环境有关，与变量本身没有关系。

2.32位平台下有32个bit位，指针变量大小是4个字节。

3.64位平台下有64个bit位，指针变量大小是8个字节。

4.务必谨记：在相同的平台下，指针变量的大小是相同的。

4.指针的解引用

下面有两组代码：

代码1：

#include<stdio.h>

int main()

{

    int n = 0x11223344;

    int* pi = &n;

    *pi = 0;

    return 0;

}

代码2：

#include<stdio.h>

int main()

{

    int n = 0x11223344;

    char* pc = (char*)&n;

    *pc = 0;

    return 0;

}

通过运行测试我们可以看到，代码1会将n的4个字节全部改为0，但是代码2只是将n的第一个字节改为0；

由此，我们可以得出，char*的指针解引用就只能访问一个字节，而int*的指针解引用就能访问四个字节。

5.void*指针

void*指针，可以理解为无具体类型的指针，这种类型的指针可以接受任意类型地址。但是也具有局限性，void*类型的指针不能直接进行指针的+-整数和解引用运算。

6.指针运算

指针的基本运算有三种，分别是：

指针+-整数； 指针-指针； 指针的关系运算

6.1指针+-整数

因为数组是在内存中连续存放的，只要知道第一个元素的地址，就可以找到其他元素。

#include<stdio.h>

int main()

{

    int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };

    int* p = &arr[0];

    int i = 0;

    int sz = sizeof(arr) / sizeof(arr[0]);

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

    {

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

    }

    return 0;

}

在这个代码中，*（p+i）中就是指针+-整数的形式。

6.2指针-指针

指针-指针可以得出两个指针之间相距的距离，但要注意的是只有在相同的指针之下才有意义！

#include<stdio.h>

int my_strlen(char* s)

{

    char* p = s;

    while (*p != '\0')

        p++;

    return p - s;

}

在这个函数中p-s就是两个指针之间的相减。此外，这个还是模仿strlen函数的一种方法，后续后有专门的总结。

6.3指针之间的关系运算

#include<stdio.h>

int main()

{

    int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };

    int* p = &arr[0];

    int sz = sizeof(arr) / sizeof(arr[0]);

    while (p < arr + sz)

    {

        printf("%d ", *p);

        p++;

    }

    return 0;

}

在这一段代码中，p<arr+sz就是指针之间的关系运算。

7.*野指针

野指针就是指针指向的位置是不可知的。

野指针的种类主要包括指针未初始化、指针越界访问、指针指向的空间释放。

野指针一般是由于人们在书写时错误的认知，还有对指针本身没有清晰的认识而造成的。

在书写过程中，我们可以通过对指针初始化、注意指针是否越界以及在指针变量不再使用时，及时置NULL等方式来有效减少野指针的出现。

8.指针传址调用

传值调用和传址调用

8.1传值调用

 

#include<stdio.h>

 

void Swap(int x, int y)

{

    int temp = x;

    x = y;

    y = temp;

}

 

int main()

{

    int a = 10;

    int b = 20;

    Swap(a, b);

    printf("a=%d b=%d\n", a, b);

}

通过运行结构在这个函数中并不能实现两个数之间的交换。

8.2传址调用

 

#include<stdio.h>

void Swap(int* px, int* py)

{

    int temp = 0;

    temp = *px;

    *px = *py;

    *py = temp;

}

 

int main()

{

    int a = 10;

    int b = 20;

    printf("a=%d b=%d\n", a, b);

    Swap(&a, &b);

    printf("a=%d b=%d\n", a, b);

}

通过运行结果我们可以看到，传址调用可以实现两个数之间数值的交换。

由此，我们可以发现，传址调用，可以实现函数与主调函数之间建立真正的联系，可以修改主调函数中的变量。

所以未来函数中只是需要主调函数中的数值来实现计算，可以采用传值调用；

需要修改函数内部中变量的值，可以采用传址调用。

9.数组名的理解

接下来我们通过一个代码来深入理解：

#include<stdio.h>

int main()

{

    int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };

    printf("&arr[0]=%p\n", &arr[0]);

    printf("arr    =%p\n", arr);

    return 0;

}

从运行结果中我们可以看出数组名和数组首元素的地址打印出的结果一模一样，所以，数组名就是数组首元素的地址。

但是，有两个例外：

1.sizeof(arr)，表示的是整个数组，计算的是整个数组的大小；

2.&数组名，这里取出的是整个数组的地址。

10.使用指针访问数组

结合前面我们已有的知识，我们就可以很好的使用指针来访问数组

#include<stdio.h>

int main()

{

    int arr[10] = { 0 };

    int i = 0;

    int sz = sizeof(arr) / sizeof(arr[0]);

    int* p = arr;

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

    {

        scanf("%d", p + i);

        //或者也可以写成arr+i

    }

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

    {

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

        //这里也可以写成p[i]

    }

    return 0;

}

11.一维数组传参的本质

本质上数组传参传递的是数组首元素的地址。

#include<stdio.h>

void test1(int arr[])

{

    printf("%d\n", sizeof(arr));

}

 

void test2(int* arr)

{

    printf("%d\n", sizeof(arr));

}

 

int main()

{

    int arr[10] = { 1,2,3,4,5,6,7,8,9,20 };

    test1(arr);

  //test2(arr);

    return 0;

}

总结：一维数组传参，形参的部分可以写成数组的形式，也可以写成指针的形式。

12.二级指针

指针变量也是变量，是变量就有地址，存放指针地址的变量就是二级指针。

例如：

#include<stdio.h>

int main()

{

    int a = 10;

    int* pa = &a;

    int* paa = &pa;

    return 0;

}

这里的paa就是用来存放指针变量pa的地址。

13.指针数组&模拟二维数组

指针数组，是存放指针的数组。指针数组中的每个元素都是用来存放地址的。指针数组的每个元素是地址，又可以指向一块区域。

指针数组模拟二位数组的代码实例：

#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[3] = { arr1,arr2,arr3 };

    

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

    {

        for (int j = 0; j < 5; j++)

        {

            printf("%d ", parr[i][j]);

        }

        printf("\n");

    }

    return 0;

}

这个代码就用指针数组parr来实现二维数组的功能。

14.字符指针变量

字符指针：char*

有两种使用方式：

#include<stdio.h>

//第一种

int main()

{

    char ch = 'w';

    char* pc = &ch;

    *pc = 'w';

    return 0;

}

 

//第二种

 

int main()

{

    const char* pstr = "hello bit.";

    //本质上是把字符串的首地址放到了pstr中

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

    return 0;

}

 15.数组指针变量

数组指针变量形式：int(*p)[10]

这里应该注意的是：[]的优先级要高于*号的，所以必须加上（）来保证p先和*结合

int arr[10] = { 0 };

int(*p)[10] = &arr;

 接下来我们通过一个代码来了解一下二维数组传参本质：

#include<stdio.h>

 

void test(int a[3][5], int r, int c)

{

    int i = 0;

    int j = 0;

    for (i = 0; i < r; i++)

    {

        for (j = 0; j < c; j++)

        {

            printf("%d ", a[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} };

    test(arr, 3, 5);

    return 0;

}

二维数组其实可以看做是每个元素是一维数组的数组，也就是二维数组的每个元素是一个一维数组。二维数组的数组名表示的就是第一行的地址。 

形参也可以写成指针形式：

#include<stdio.h>

 

void test(int(*p)[5], int r, int c)

{

    int i = 0;

    int j = 0;

    for (i = 0; i < r; i++)

    {

        for (j = 0; j < c; 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} };

    test(arr, 3, 5);

    return 0;

}

16.函数指针变量

函数指针变量形式：int (*p) (int x, int y)

函数指针变量的使用如下：

int ADD(int x, int y)

{

    return x + y;

}

int main()

{

    int(*p)(int, int) = ADD;

    printf("%d\n", (*p)(2, 3));

    printf("%d\n", p(3,5));

    return 0;

}

我们下一个知识点见~