C语言第十三课--------初阶指针的认识--------重要部分

插播小知识

1.全局变量，没有给初始值时，编译其会默认将其初始化为0。局部变量必须初始化。如int a;

2.'\0'是/ddd ,就是0

3.数组名是一个常量,不能++,相当于5++是错的,如果存放到一个变量里面,变量就可以++,

指针是什么

1. 指针是内存中一个最小单元的编号，也就是地址

2. 平时口语中说的指针，通常指的是指针变量，是用来存放内存地址的变量

总结：指针就是地址，口语中说的指针通常指的是指针变量

#include <stdio.h>
int main()
{
  int a = 10;//是向内存中栈区空间申请4个字节的空间，这4个字节用来存放10这个数值
  int* p = &a;//这里我们对变量a，取出它的地址，可以使用&操作符。a变量占用4个字节的空间，这里是将
  //a的4个字节的空间,这里将a的4个字节的空间,这里是将a的4个字节的第一个字节的地址存放在p变量中,p就是一个指针变量
  return 0;
}

存储地址连续的话只取第一个字节地址进行存储

指针变量，用来存放地址的变量。（存放在指针中的值都被当成地址处理）。

一个小的内存单元是1个字节

对于 32 位的机器，假设有 32 根地址线，那么假设每根地址线在寻址的时候产生高电平（高电压）和低电平（低电压）就是（1 或者 0 ）；上图是32根地址线,可以产生2^32次方个编码,

内存的大小是可以设置的

如果每个编码指向一个字节的内存,2^32次方个字节,那么就会有4G的内存

在 32 位的机器上，地址是 32 个 0 或者 1 组成二进制序列，那地址就得用 4 个字节的空间来存储，所以

一个指针变量的大小就应该是 4 个字节。

那如果在 64 位机器上，如果有 64 个地址线，那一个指针变量的大小是 8 个字节，才能存放一个地

址

地址的大小是由地址线决定的,一根地址线一个bit位

总结:

1.内存被划分成一个个的内存单元,每个内存单元是一个字节

2.每个字节的内存单元都有一个编号,这个编号就是地址,地址在C语言中被称为指针

3.地址要存储的话,存放在指针变量中

4.每个内存单元都有一个唯一的地址来标识

5.在32位机器上地址的大小是4个字节,所以指针变量的大小也是4个字节,同理在64位机器上地址的大小是8个字节,所以指针变量的大小也是8个字节

指针和指针类型

从上图可以看出&a的地址和a里面存储的样式,当我们使用*p进行修改值的时候就会有

可以发现四个字节全部修改了,

如果我们换成 char* p来接受&a,再利用*p修改

就会发现只修改了一个字节,所以指针类型大小一样,但是解引用的进行操作时就会不一样,

1.即指针类型决定了解引用操作是操作几个字节 ,char* 操作一个字节,short* 操作两个字节

char* p还是int *p 存储同一个地址,里面的内容是不变的

如果地址加1 就会有不一样的效果,

2.指针类型的决定了地址加1 是跳过几个字节.比如 char* p   p+1跳过一个字节, int* 的指针加1跳过4个字节

野指针

野指针就是指针指向的位置是不可知的（随机的、不正确的、没有明确限制的）

#include <stdio.h>
int a;
int main()
{
  int* p = 0x11223344;
  *p;
  printf("%d", a);
  return 0;
}

存放的内容不是程序内的，

野指针成因

1.指针未初始化

在vs编译器如果指针变量未初始化，就会报错

#include <stdio.h>
int main()
{
  int* p;
  *p = 10;
  return 0;
}

2. 指针越界访问

#include <stdio.h>
int main()
{
  int arr[10] = { 0 };
  int* p = arr;
  int i = 0;
  for (i = 0; i <= 10; i++)
  {
    *p = 1;
    p++;
  }
  return 0;
}

如果越界访问就会报错 ，当指针越界（超出数组arr的范围），p就是指针

3. 指针指向的空间释放

#include <stdio.h>
int* test()
{
  int a = 0;
  return &a;
}
int main()
{
  int* p = test();
  //p指向了被释放的地址，p就是野指针
  printf("%d", *p);
  return 0;
}

p指向了被释放的地址，p就是野指针

规避野指针

1. 指针初始化

如果不知道初始化什么值就初始化NULL

int* p = NULL

NULL是0

2. 小心指针越界

3. 指针指向空间释放即使置 NULL

4. 避免返回局部变量的地址

5. 指针使用之前检查有效性

指针运算

#include <stdio.h>
int main()
{
  int arr[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
  int* p = arr;
  int i = 0;
  for (i = 0; i < 10; i++)
  {
    printf("%d ", *(p + i));//p指向的是数组首元素的地址
    // p+i 是数组中下标为i的元素的地址
  }
  return 0;
}

以上图为例

arr == p   可以推出 arr+i == p+i   也能推出 *(arr+i) == *(p+i) ==arr[i] ,更能写成*(i+arr) == i[arr],

指针+- 整数

#define SZ 5
#include <stdio.h>
int main()
{
  int arr[SZ];
  int* p = arr;
  for (p = arr; p < &arr[SZ];)
  {
    *p++ = 0;
  }
  return 0;
}

p < &arr[SZ]的原理为:

指针的关系运算

#define SZ 5
#include <stdio.h>
int main()
{
  int arr[10];
  int* p = NULL;
  for (p = &arr[SZ]; p > &arr[0];)
  {
    *--p = 0;
  }
  return 0;
}

标准规定：

允许指向数组元素的指针与指向数组最后一个元素后面的那个内存位置的指针比较，但是不允许与

指向第一个元素之前的那个内存位置的指针进行比较。

简单的理解是数组元素地址只能和数组之后的的地址比较,不能和之前的比较

指针-指针

#define SZ 5
#include <stdio.h>
int main()
{
  int arr[SZ];
  printf("%d", &arr[9] - &arr[0]);
  return 0;
}

指针-指针的前提:两个指针指向同一块区域,指针类型要相同

指针-指针差值的绝对值是指针和指针之间的元素个数

指针和数组

指针就是指针(指针变量),指针大小为4/8

数组就是数组,存放一组数据的,数组的大小取决于数组元素的个数和类型,

数组名是首元素的地址,但有两个例外:

1.sizeof 的数组名表示整个数组,计算的是整个数组的大小

2.&数组名,表示的是整个数组,取出的是数组的地址,数组的地址和数组首元素的地址,值是一样的,但是类型和意义不一样

二级指针

#include<stdio.h>
int main()
{
  int a = 9;
  int* p = &a;//p是指针变量,一级指针
  int** pp = &p;//pp是指针变量, 二级指针
  int*** ppp = &pp;//ppp是指针变量, 三级指针
  *ppp; //pp
  **ppp;//p
  ***ppp;//a
  ***ppp = 10;
  printf("%d", a);
  return 0;
}

二级指针简单理解就是用于存放一级指针地址的指针变量

指针数组

字符数组:存放字符的数组

整形数组:存放整形的数组

那么指针数组就是存放指针的数组

char * arr[] 存放字符指针的数组

short * arr[] 存放短整型指针的数组

int* arr[] 存放整形指针的数组

#include<stdio.h>
int main()
{
  int arr1[] = { 1,2,3,4,5,6,7 };
  int arr2[] = { 2,3,4,5,6,7,8 };
  int arr3[] = { 3,4,5,6,7,8,9 };
  int* arr[] = { arr1, arr2, arr3 };
  int i = 0;
  for (i = 0; i < 3; i++)
  {
    int j = 0;
    for (j = 0; j < 5; j++)
    {
      printf("%d ", arr[i][j]);
    }
    printf("\n");
  }
  return 0;
}

总结:

初阶指针就介绍到这里了有不懂的小可爱可以私聊我