C语言----指针&结构体

指针是什么？在计算机科学中，指针（Pointer）是编程语言中的一个对象，利用地址，它的值直接指向（points to）存在电脑存储器中另一个地方的值。由于通过地址能找到所需的变量单元，可以 说，地址指向该变量单元。因此，将地址形象化的称为“指针”。意思是通过它能找到以它为地址 的内存单元。指针 指针是个变量，存放内存单元的地址（编号）。

#include <stdio.h> int main()
{
int a = 10;//在内存中开辟一块空间
int *p = &a;//这里我们对变量a，取出它的地址，可以使用&操作符。
//将a的地址存放在p变量中，p就是一个之指针变量。
return 0;
}

指针就是变量，用来存放地址的变量。（存放在指针中的值都被当成地址处理）。
指针是用来存放地址的，地址是唯一标示一块地址空间的。 指针的大小在32位平台是4个字节，在64位平台是8个字节。
指针和指针类型

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()
{
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;
}

指针的类型决定了指针向前或者向后走一步有多大（距离）。
指针的解引用

指针的类型决定了，对指针解引用的时候有多大的权限（能操作几个字节）。 比如： char* 的指针解引用就只能访问一个字节，而 int* 的指针的解引用就能访问四个字节。野指针

概念： 野指针就是指针指向的位置是不可知的（随机的、不正确的、没有明确限制的）指针变量 在定义时如果未初始化，其值是随机的，指针变量的值是别的变量的地址，意味着指针指向了一 个地址是不确定的变量，此时去解引用就是去访问了一个不确定的地址，所以结果是不可知的。

野指针成因

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. 指针指向的空间释放

如何规避野指针

1. 指针初始化
2. 小心指针越界
3. 指针指向空间释放即使置NULL
4. 指针使用之前检查有效性
   指针运算

指针± 整数
#define N_VALUES 5
float values[N_VALUES];
float *vp;
//指针±整数；指针的关系运算
for (vp = &values[0]; vp < &values[N_VALUES]😉
{
*vp++ = 0;
}
指针-指针
int my_strlen(char *s)
{
char *p = s;
while(*p != ‘\0’ )
p++;
return p-s;
}
指针的关系运算
for(vp = &values[N_VALUES]; vp > &values[0]😉
{
*–vp = 0;
}
for(vp = &values[N_VALUES-1]; vp >= &values[0];vp–)
{
*vp = 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]); for(i=0; i<sz; i++)
{
printf("&arr[%d] = %p <====> p+%d = %p\n", i, &arr[i], i, p+i);
}
return 0;
}
所以 p+i 其实计算的是数组 arr 下标为i的地址。 那我们就可以直接通过指针来访问数组
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;
}

二级指针

指针变量也是变量，是变量就有地址，那指针变量的地址存放在哪里？ 这就是 二级指针

对于二级指针的运算有：

*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* arr3[5];//是什么？
arr3是一个数组，有五个元素，每个元素是一个整型指针

结构体

结构体类型的声明
结构体的声明
结构的基础知识 结构是一些值的集合，这些值称为成员变量。结构的每个成员可以是不同类型的变量。
结构的声明
struct tag
{
member-list;
}variable-list;
结构成员的类型
结构的成员可以是标量、数组、指针，甚至是其他结构体。

结构体初始化
struct Point
{
int x; int y;
}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};//结构体嵌套初始化

结构体成员访问
结构体变量访问成员 结构变量的成员是通过点操作符（.）访问的。点操作符接受两个操作数。

我们可以看到 s 有成员 name 和 age ； 那我们如何访问s的成员？
struct S s;
strcpy(s.name, “zhangsan”);//使用.访问name成员 s.age = 20;//使用.访问age成员

结构体指针访问指向变量的成员 有时候我们得到的不是一个结构体变量，而是指向一个结构体的 指针。
那该如何访问成员。 如下：
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;
}

结构体传参

函数传参的时候，参数是需要压栈的。 如果传递一个结构体对象的时候，结构体过大，参数压栈 的的系统开销比较大，所以会导致性能的下降。
结论： 结构体传参的时候，要传结构体的地址。

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;
}
首选print2函数