😛
指针
1）指针是什么
- 在计算机中，所有的数据都是存放在存储器中的，不同的数据类型占有的内存空间的大小各不相同。内存是以字节为单位的连续编址空间，每一个字节单元对应着一个独一的编号，这个编号被称为内存单元的地址。比如：int 类型占 4 个字节，char 类型占 1 个字节等。系统在内存中，为变量分配存储空间的首个字节单元的地址，称之为该变量的地址。地址用来标识每一个存储单元，方便用户对存储单元中的数据进行正确的访问。在高级语言中地址形象地称为指针.
指针理解的两个要点：
1.指针是内存中一个最小单元的编号，也就是地址
2. 平时口语中说的指针，通常指的是指针变量，是用来存放内存地址的变量
总结：指针就是地址，口语中说的指针通常指的是指针变量
指针变量
我们可以通过&（取地址操作符）取出变量的内存其实地址，把地址可以存放到一个变量中，这个变量就是指针变量
#include <stdio.h>
int main()
{
int a = 10;//在内存中开辟一块空间
int *p = &a;//这里我们对变量a，取出它的地址，可以使用&操作符。
//a变量占用4个字节的空间，这里是将a的4个字节的第一个字节的地址存放在p变量
//中，p就是一个之指针变量。
return 0;
}
总结
指针变量，用来存放地址的变量。（存放在指针中的值都被当成地址处理）。
那这里的问题是：
- 一个小的单元到底是多大？（1个字节）
- 如何编址？
经过仔细的计算和权衡我们发现一个字节给一个对应的地址是比较合适的。
对于32位的机器，假设有32根地址线，那么假设每根地址线在寻址的时候产生高电平（高电压）和低电
平（低电压）就是（1或者0）；
那么32根地址线产生的地址就会是：
00000000 00000000 00000000 00000000
00000000 00000000 00000000 00000001
…
11111111 11111111 11111111 11111111
这里就有2的32次方个地址。
每个地址标识一个字节，那我们就可以给（2^ 32Byte = = 2^ 32/1024KB= =2^ 32/1024/1024MB==2^32/1024/1024/1024GB == 4GB） 4G的空闲进行编址
我们理解为：
- 在32位的机器上，地址是32个0或者1组成二进制序列，那地址就得用4个字节的空间来存储，所以一个指针变量的大小就应该是4个字节。
- 那如果在64位机器上，如果有64个地址线，那一个指针变量的大小是8个字节，才能存放一个地址
总结：
- 指针是用来存放地址的，地址是唯一标示一块地址空间的。
- 指针的大小在32位平台是4个字节，在64位平台是8个字节。
2）指针和指针类型
int num = 10;
p = #
要将&num（num的地址）保存到p中，我们知道p就是一个指针变量，那它的类型是怎样的呢？
我们给指针变量相应的类型。
char *pc = NULL;
int *pi = NULL;
short *ps = NULL;
long *pl = NULL;
float *pf = NULL;
double *pd = NULL;
这里可以看到，指针的定义方式是： type + * 。
char* 类型的指针是为了存放 char 类型变量的地址。
short* 类型的指针是为了存放 short 类型变量的地址。
int* 类型的指针是为了存放 int 类型变量的地址。
那指针类型的意义是什么？
#include <stdio.h>
int main(void)
{
int a = 0X12345678;
int *p = &a;
printf("%X\n",*p);
printf("%X\n",*((char*) p));
return 0;
}
-
第一个打印结果为：12345678 原因 :p 是 int * 类型。即：p 的寻址能力为int，也就是4个字节，所以*p 打印12345678
-
第二个打印的结果为：78 原因：p 是int * 类型。将p强转成char* 类型，即：p 的寻址能力降低为1个字节，而第一个字节中存放的是78。（小端存储）所以：((char) p) 打印78
2.1）指针±整数
#include <stdio.h>
int main()
{
int n = 10;
char* pc = (char*)&n;
int* pi = &n;
printf("%p\n", &n);
printf("%p\n", pc);
printf("%p\n", pc + 1);
printf("%p\n", pi);
printf("%p\n", pi + 1);
return 0;
}
总结：指针的类型决定了指针向前或者向后走一步有多大（距离）
2.2）指针的解引用
#include <stdio.h>
int main()
{
int n = 0x11223344;
char* pc = (char*)&n;
int* pi = &n;
*pc = 0;
*pi = 0;
return 0;
}
总结：
- 指针的类型决定了，对指针解引用的时候有多大的权限（能操作几个字节）。
- 比如： char* 的指针解引用就只能访问一个字节，而 int* 的指针的解引用就能访问四个字节。
3）野指针
C 语言中指针初始化是指给所定义的指针变量赋初值。指针变量在被创建后，如果不被赋值，他的缺省值是随机的，它的指向是不明确的，这样的指针形象地称为 “ 野指针 ”。野指针是很危险的，容易造成程序出错，且程序本身无法判断指针指向是否合法）
3.1）野指针成因
1）指针未初始化
#include <stdio.h>
int main()
{
int *p;//局部变量指针未初始化，默认为随机值
*p = 20;
return 0;
}
2）指针越界访问
#include <stdio.h>
int main()
{
int arr[10] = {0};
int *p = arr;
int i = 0;
for(i=0; i<=11; i++)
{
//当指针指向的范围超出数组arr的范围时，p就是野指针
*(p++) = i;
}
return 0;
}
3）指针指向的空间释放
#include<stdio.h>
#include<stdlib.h>
int main()
{
int* arr = (int*)malloc(sizeof(int) * 2);
for (int i = 0;i < 2;i++)
{
scanf("%d", &arr[i]);
}
free(arr);
printf("%d", *(arr));//因为arr已经被摧毁，这是arr就是野指针
return 0;
}
3.2）如何规避野指针
- 指针初始化
- 小心指针越界
- 指针指向空间释放即使置NULL
- 避免返回局部变量的地址
- 指针使用之前检查有效性
4）指针运算
- 指针± 整数
- 指针-指针
- 指针的关系运算
4.1）指针±整数
#include<stdio.h>
int main()
{
int n = 10;
int* p = &n;
for (int i = 0;i < 3;i++)
{
printf("%p\n",(p++));
}
return 0;
}
总结： 指针±整数实际上是其地址±（对应基类型）×（整数）
4.2）指针-指针
#include<stdio.h>
int my_strlen(char* s) {
char* p = s;
while (*p != '\0')
p++;
return p - s;
}
int main()
{
char arr[] = "Hello";
int ret = my_strlen(arr);
printf("%d", ret);
return 0;
}
总结： 结果为二者之间的元素个数
5）指针和数组
#include <stdio.h>
int main()
{
int arr[10] = {1,2,3,4,5,6,7,8,9,0};
printf("%p\n", arr);
printf("%p\n", &arr[0]);
return 0;
}
可见数组名和数组首元素的地址是一样的。
结论：数组名表示的是数组首元素的地址。
#include<stdio.h>
int main()
{
int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
int* p = arr;
int sz = sizeof(arr) / sizeof(arr[0]);
int i = 0;
for (i = 0; i < sz; i++)
{
printf("%d ", *(p + i));
}
return 0;
}
总结： 所以 p+i 其实计算的是数组 arr 下标为i的地址。那我们就可以直接通过指针来访问数组。
6）二级指针
#include<stdio.h>
int main()
{
int a = 10;
int* pa = &a;
int** ppa = &pa;
return 0;
}
7）指针数组
指针数组是指针还是数组？
答案：是数组。是存放指针的数组。
数组我们已经知道整形数组，字符数组。
int arr1[5];
char arr2[6];
int* arr3[5]
- arr3是一个数组，有五个元素，每个元素是一个整形指针
结构体
1）结构体的声明
1.1）结构的基础知识
结构是一些值的集合，这些值称为成员变量。结构的每个成员可以是不同类型的变量
1.2）结构的声明
struct tag
{
member-list;
}variable-list;
例如描述一个学生：
typedef struct Stu
{
char name[20];//名字
int age;//年龄
char sex[5];//性别
char id[20];//学号
}Stu；//分号不能丢
1.3）结构成员的类型
结构的成员可以是标量、数组、指针，甚至是其他结构体。
1.4） 结构体变量的定义和初始化
struct Point
{
int x;
int y;
}p1; //声明类型的同时定义变量p1
struct Point p2; //定义结构体变量p2
//初始化：定义变量的同时赋初值。
struct Point p3 = {x, y};
struct Stu //类型声明
{
char name[15];//名字
int age; //年龄
};
struct Stu s = {"zhangsan", 20};//初始化
struct Node
{
int data;
struct Point p;
struct Node* next;
}n1 = {10, {4,5}, NULL}; //结构体嵌套初始化
struct Node n2 = {20, {5, 6}, NULL};//结构体嵌套初始化
2）结构体成员的访问
- 结构体变量访问成员
结构变量的成员是通过点操作符（.）访问的。
#include<stdio.h>
struct Stu
{
char name[20];
int age;
};
void print(struct Stu* ps) {
printf("name = %s age = %d\n", (*ps).name, (*ps).age);
//使用结构体指针访问指向对象的成员
printf("name = %s age = %d\n", ps->name, ps->age);
}
int main()
{
struct Stu s = { "zhangsan", 20 };
print(&s);//结构体地址传参
return 0;
}
3）结构体传参
struct S {
int data[1000];
int num;
};
struct S s = { {1,2,3,4}, 1000 };
//结构体传参
void print1(struct S s) {
printf("%d\n", s.num);
}
//结构体地址传参
void print2(struct S* ps) {
printf("%d\n", ps->num);
}
int main()
{
print1(s); //传结构体
print2(&s); //传地址
return 0;
}
上面的 print1 和 print2 函数哪个好些？
答案是：首选print2函数。
原因：
函数传参的时候，参数是需要压栈的。
如果传递一个结构体对象的时候，结构体过大，参数压栈的的系统开销比较大，所以会导致性能的下降。
结论：
- 结构体传参的时候，要传结构体的地址。