C语言基础11指针

指针的引入

• 为函数修改实参提供支持。
• 为动态内存管理提供支持。
• 为动态数据结构提供支持。
• 为内存访问提供另一种途径。

指针概述

• 内存地址：
  系统为了内存管理的方便，将内存划分为一个个的内存单元（ 1 个内存单元占 1 个字节），并为每一个内存单元进行了编号，内存单元的编号称为该内存单元的地址。一般情况下，我们每一个变量都是由多个内存单元构成的，所以每个变量的内存地址，其实就是这个变量对应的第一个内存单元的地址，也叫首地址。
• 变量指针：变量地址称为该变量的指针。变量地址往往是指变量在内存中第一个内存单元的编号（首地址）。
• 指针变量：存放其他变量地址的变量。
• 指向：指针变量中存放“谁”的地址，就说明该指针变量指向了“谁”。
• *：指针运算符

案例：

/**
* 指针 初识 
*/ 

#include <stdio.h> 
void main() 
{ 
// 定义一个普通/一般变量 
int i = 3; 
// 定义一个指针变量，并赋值 
int *i_point = &i; // 指针变量的数据类型要和存储的地址变量类型一致 
// 访问普通变量（直接访问） 
printf("直接访问-%d\n",i); // 3 
// 访问指针（地址访问）%p访问地址 
printf("地址访问-%p\n",i_point); 
// 访问指针变量（间接访问） 
printf("间接访问-%d\n",*i_point); // 3 
} 

指针变量的定义

语法

数据类型 *变量列表

举例：

int a; //普通变量
int *a,*b;//指针变量

注意：

1. 虽然定义指针变量 *a ，是在变量名前加上 * ，但是实际变量名为 a ，而不是 *a ；

2. 使用指针变量间接访问内存数据是，指针变量必须要有明确的指向；

3. 如果想借助指针变量间接访问指针变量保存的内存地址上的数据，可以使用指针变量前加 * 来间

接访问；

        指针变量前加 * ，也称为对指针变量 解引用 。

int i = 5, *p; 
p = &i; // 将i的地址赋值给指针变量p 
printf("%d\n",*p);// 间接访问i的值，也称为解引用p对应地址空间的值

4.指针变量只能指向同类型的变量，借助指针变量访问内存，一次访问的内存大小是取决于指针变量的类型。

5. 指针变量在定义同时可以初始化：这一点和普通变量是一样的

int i = 5;
 int *p = &i; // 定义的同时初始化

指针变量的使用

使用

指针变量的赋值：

// 方式1 
int a,*p; 
p = &a; // 指针变量的值是其他变量的地址 
// 方式2 
int a,*p,*q = &a; 
p = q; 

操作指针变量的值：

int a,*p,*q = &a; 
p = q; 
printf("%p",p); // 此时返回的是变量a的地址空间 

操作指针变量指向的值：

int a =6,*q = &a; 

printf("%d",*q); // 6 

两个有关运算符的使用

＆ 取地址运算符。 &a 是变量 a 的地址。

*   指针运算符 （或称 “ 间接访问 ” 运算符）， *p 是指针变量 p 指向的对象的值。

案例：

#include <stdio.h> 
void main() 
{ 
int a,b; 
int *pointer_1, *pointer_2; 
a=100; b=10; 
pointer_1=&a; 
pointer_2=&b; 
printf("a=%d,b=%d\n",a,b); 
printf("pointer_1=%d,pointer_2=%d\n",*pointer_1,*pointer_2); 
} 

案例一：

代码：

/**
* 需求：声明a,b两个一般变量，使用间接存取的方式实现数据的交换？ 
*/ 
#include <stdio.h> 
void main() 
{ 
// 声明5个变量 
int a = 3,b = 5,*p_a=&a,*p_b=&b,*p_t; 
// 交换前输出 
printf("%d,%d\n",*p_a,*p_b); 
// 交换位置 
p_t = p_a; 
p_a = p_b; 
p_b = p_t; 
// 交换后输出 
printf("%d,%d\n",*p_a,*p_b); 
} 

案例二：

代码：

/* 
需求：指针变量应用。输入a、b两个整数，按先大后小的顺序输出a和b。 
*/ 
#include <stdio.h> 
void main() 
{ 
int a = 3,b = 5,*p_a = &a,*p_b = &b,*p_t; 
if( a < b) 
{ 
p_t = p_a;// 操作指针变量，不会影响到数据本身 
p_a = p_b; 
p_b = p_t; 
}
printf("按从大到小输出a,b的值：%d > %d\n",*p_a,*p_b); 
} 

代码：不推荐

/* 
需求：指针变量应用。输入a、b两个整数，按先大后小的顺序输出a和b。 
*/ 
#include <stdio.h> 
void main() 
{ 
int a = 3,b = 5,*p_a = &a,*p_b = &b,*p_t; 
if( a < b) 
{ 
*p_t = *p_a;// 操作指针地址指向的内存空间，也就是直接操作变量a 
*p_a = *p_b; 
*p_b = *p_t; 
}
printf("按从大到小输出a,b的值：%d > %d\n",*p_a,*p_b); 
} 

指针变量做函数参数

指针变量做函数参数往往传递的是变量的地址（首地址），借助于指针变量间接访问是可以修改实参变量数据的。

案例一：

需求：要求用函数处理，用指针变量作函数的参数

方式一：交换指向（指向的普通变量值不变）

#include <stdio.h> 
/* 需求：指针变量应用。输入a、b两个整数，按先大后小的顺序输出a和b。 */ 
/* 自定义函数，实现两个数的比较 */ 
void swap(int *p_a,int *p_b) 
{ 
int *p_t; 
// 这种写法，只会改变指向，不会改变地址对应空间的数据 
p_t = p_a; 
p_a = p_b; 
p_b = p_t; 
printf("%d > %d\n",*p_a,*p_b); // 5 > 3 
}
void main() 
{ 
int a = 3,b = 5; 
if(a < b) swap(&a,&b); // int *p_a = &a,int *p_b = &b 
printf("%d > %d\n",a,b);// 3 > 5 
} 

方式二：交换值（指向的普通变量的值改变）

#include <stdio.h>
/* 需求：指针变量应用。输入a、b两个整数，按先大后小的顺序输出a和b。 */ 
/* 自定义函数，实现两个数的比较 */ 
void swap(int *p_a,int *p_b) 
{ 
int t; 
// 这种写法，只会改变指向，不会改变地址对应空间的数据 
t = *p_a; 
*p_a = *p_b; 
*p_b = t; 
printf("%d > %d\n",*p_a,*p_b); // 5 > 3 
}
void main() 
{ 
int a = 3,b = 5; 
if(a < b) swap(&a,&b); // int *p_a = &a,int *p_b = &b 
printf("%d > %d\n",a,b);// 5 > 3 
} 

通过指针引用数组

数组元素的指针

• 数组指针：数组的首地址
• 指针数组：存放数组元素地址的数组

//定义一个一般数组
int a[] = {1,4,9};
//使用指针变量存储数组的第一个元素的首地址，也就是数组的首地址
int *p = &a[0];

//在C语言中，由于数组名代表数组的首地址，因此，数组名实际上也是指针。
int *p = a;

//意味着：int *p = &a[0] 完全等价于 int *p = a;

printf("%d\n",*p);// 1

指针的运算

指针运算：指针变量必须要指向数组中的某个元素

序号	指针运算	说明
1	自增：p++、++p、p = p+1(p+=1)	让指针指向下一个元素
2	自减：p--、--p、p -= 1	让指针指向上一个元素
3	加一个数：p+1	下个元素的（首）地址
4	减一个数：p-1	上一个元素的（首）地址
5	指针相减：p1 - p2	p1、p2之间相差几个元素
6	指针比较：p1<p2	前面的指针小于后面的指针（元素地址）

案例一：

#include <stdio.h> 
int main() 
{ 
// 一般数组 
int a[] = {1,3,5,7,9}; 
// 计算数组中元素的个数 
// sizeof用法：sizeof(运算数) 或者 sizeof 运算数 
int len = sizeof a / sizeof a[0]; 
// 创建指针变量 
int *p = a; 
// 创建循环变量 
register int i = 0; 
// 遍历 
for(;i < len; i++) 
{ 
printf("[1] %d ",a[i]); // 下标法 
printf("[2] %d ",*(a+i));// 指针法，但是这种写法，需要注意，a+i无法修改数组，只读 
printf("[3] %d ",*(p+i));// 指针法，这种更为灵活，可读可写，建议这种写法 
p++; 
// printf("%d\n",*p); // 等价于上面写法 
// p++; 
}
printf("\n"); 
return 0; 
} 

案例2：

#include <stdio.h>
int main() 
{ 
int a[] = {10,22,33,44,55,66,77,88}; 
int *p = a;// 等价于 int *p = &a[0] 元素：10 
p++;// 指针+1，元素值不改变 元素：22 
printf("%d\n",*p);// p = p + 1 元素：22 
int x = *p++;// x = 22,p++ -- *p：33 
printf("%d,%d\n",x,*p);// *p++：先*p,在p++, 元素：22,33 
int y = *(++p);// ++p, y = 44; 
printf("%d,%d\n",y,*p); // *(++p)：先p++,再*p，元素：44,44 
(*p)++;// 元素值+1,指针不改变 
printf("%d\n",*p);// index为3的元素值：44 + 1 = 45 
return 0; 
} 

数组名做函数参数

表现形式：

1. 形参和实参都用数组名

2. 实参用数组名，形参用指针变量

3. 实参形参都用指针变量

void fun(int *p1){} 
void main() 
{ 
// 注意：如果实参和形参都是指针，我们的实参需要初始化 
int arr[2] = {23,34}; 
int *p0 = arr; 
fun(p0); 
} 

4. 实参为指针变量，形参为数组名

案例一：

/**
* 需求：将数组ａ中n个整数按相反顺序存放。 
*/ 
#include <stdio.h> 
/* 数组的反转：数组实现*/ 
void inv(int arr[],int len) 
{ 
// 反转思路：将第0个和n-1个进行对掉，将第1个和n-2个对掉.. 
// 定义循环变量i，临时变量temp 
int i = 0,temp; 
// 遍历数组 
for(;i < len/2;i++) 
{ 
// 交换 
temp = arr[i]; 
arr[i] = arr[len-1-i]; 
arr[len-1-i] = temp; 
} 
}
/*
数组的反转：指针实现 
关键字：const 给变量的数据类型前面添加const，代表这个变量是只读变量，无法对此作出修改 
*/
void inv2(int *arr,const int len) 
{ 
// 反转思路：将第0个和n-1个进行对掉，将第1个和n-2个对掉.. 
// 定义循环变量i，临时变量temp *j = &arr[len -1] 等价于 arr + len -1 
int *i = arr,*j = &arr[len-1],temp; 
// 遍历数组 
for(;i < j;i++,j--) 
{ 
// 交换 
temp = *i; 
*i = *j; 
*j = temp; 
} 
}
int main() 
{ 
int array[10] = {12,23,45,55,66,77,88,26,34,32}; 
int len = sizeof(array)/sizeof(int); 
inv2(array,len); 
// 测试是否反转 
for(int i = 0;i < len;i++) printf("%d,",array[i]); 
printf("\n"); 
return 0; 
} 

数组指针

数组指针：指向一维数组的指针变量。

数组指针定义：假定该指针变量指向具有 N 个元素的一维数组，则数组指针变量定义如下：

数据类型 (*数组指针变量名)[N];

一维数组：

int a[N] = {1,2,3}; 
int (*p)[N] = &a;

二维数组：

int a[][N] = {1,3,5,7}; 
int (*p)[N] = a[0];// &a[0][0]

分析：

int arr[3] = {1,2,3}; 
int *p = arr;// &arr[0] 首地址：第1个元素的首地址 
int (*p)[3] = &arr; 
// p = &arr[0]; 
int arr[][3] = {1,2,3,4,5,6}; 
int *p = arr[0]; // &arr[0][0] 首地址：第1行第1列元素的首地址 
int (*p)[3] = &arr[0]; 
// p = &arr[0][0] 

案例：

/**
* 数组指针： 用指向元素的指针变量输出二维数组元素的值 
*/ 
#include <stdio.h> 
int main() 
{ 
// 定义一个普通的二位数组 
int a[3][4] = {1,3,5,7,9,11,13,15,17,19,21,23}; 
int *p = &a[0][0];// 二维数组 等价于 a[0] 
// 循环遍历 
for(;p < a[0]+12;p++) 
{ 
if((p - a[0]) % 4 == 0) 
{ 
printf("\n"); 
}
printf("%4d",*p); 
}
printf("\n"); 
return 0; 
} 

案例：

/**
* 数组指针：输出二维数组任一行任一列元素的值。 
此时：我们需要将二维数组看作是一个特殊的一维数组 
*/ 
#include <stdio.h> 
int main() 
{ 
int a[3][4] = {1,3,5,7,9,11,13,15,17,19,21,23}; 
int (*p)[4]; // 我们把行使用指针表示 
p = &a[0]; // 等价于 p = a 
int i,j;// 代表我们要显示的数据对应的行号和列号 
printf("请输入行号和列号：\n"); 
scanf("i=%d,j=%d",&i,&j); 
printf("a[%d][%d]=%d\n",i,j,*(*(p+i)+j)); 
return 0; 
} 

函数的传参

• 值传递：一般发生在函数形参的类型为char、short、int、long、float、double这样的类型，它的传递，一般是实参将自己的值复制一份给形参，也就是实参变量和形参变量的变量空间是分开的。此时形参无法改变实参的数据。
• 引用传递：一般发生在函数形参的类型为数组、指针这样的类型，它的传递，一般是实参将自己的内存首地址复制一份给形参，也就是实参变量和形参变量对应内存空间是同一个。此时形参可以改变实参的数据。

数组指针与指针数组

数组指针

• 概念：数组指针是指向数组的指针。
• 特点：
  • 先有数组，后有指针
  • 它指向的是一个完整的数组。
• 一维数组指针：
  • 语法:

数据类型 (*指针变量名)[容量]；

案例：

/**
* 数组指针：指向数组的指针 
*/ 
#include <stdio.h> 
int main() 
{ 
// 一维数组指针 
// 先有数组，再有指针 
int arr[3] = {100,200,300}; 
// 获取数组的元素个数 
int len = sizeof arr / sizeof arr[0]; 
// 定义一个数组指针，指向arr数组 
// 数组指针的语法：数据类型 (*指针变量名)[容量]; 
int (*p)[3] = &arr;// 此时p不是指向arr数组的第一个元素，而是指向arr这个数组本身 
printf("%p\n",p); 
// p++; 此时p++会跳出整个数组 
// printf("%p\n",p); 
printf("%d\n",(*p)[2]);// 300 
// 遍历 
for(int i = 0; i < len; i++) 
{ 
printf("%d\n",(*p)[i]); 
}
printf("\n"); 
// int *p = &arr[0] | arr;// 这种写法，代表p指向的不是数组本身，是数组中的第一个元素 
} 

指针和数组中符号优先级： () > [] > *

指针数组

• 概念：指针数组是一个数组，数组中的每个元素都是一个指针。
• 特点：
  • 先有“指针”，后有“数组”
  • 指针数组的本质是一个数组，只是数组中的元素类型为指针。
• 语法：

数据类型 *数组名[容量];

案例：

/**
* 指针数组 
*/ 
#include <stdio.h> 
int main() 
{ 
// 定义三个变量 
int a = 10, b = 20, c = 30; 
// 定义指针数组，指针数组用来存放指针（变量或者常量的内存地址） 
int *arr[3] = {&a,&b,&c}; 
// 获取数组的大小 
int len = sizeof arr / sizeof arr[0]; 
// 遍历数组 
for(int i = 0; i < len; i++) 
{ 
printf("%3d",*(arr[i])); // 输出每个指针所指向的值，需要解引用 
}
printf("\n"); 
return 0; 
} 

建议：我们一般使用指针数组处理字符串

字符串指针

字符串实现

在 C 语言中，表示一个字符串有以下两种形式：

1. 用字符数组存放一个字符串

2. 用字符指针指向一个字符串

案例：

/**
* 字符串的两种实现方式 
*/ 
#include <stdio.h> 
/* 使用字符数组实现 */ 
void fun() 
{ 
// 定义伪字符串 
char str[] = "I Love Your!"; 
printf("%s\n",str); 
}
/* 使用字符指针实现 */ 
void fun1() 
{ 
// 定义伪字符串 
char *str = "I Love Your!"; 
printf("%s\n",str); 
}
int main() 
{ 
fun(); 
fun1(); 
return 0; 
} 

注意：字符数组和字符指针变量都能实现字符串的存储与运算。

字符数组和字符指针的联系

• 字符数组由元素组成，每个元素中存放一个字符，而字符指针变量中存放的是地址，也能作为函数参数。
• 只能对字符数组中的各个元素赋值，而不能用赋值语句对整个字符数组赋值。
• 字符数组名虽然代表地址，但数组名的值不能改变。因为数组名是常量。
• 对于字符串中字符的存取，可以用下标法，也可以用指针法。

案例：

/**
* 字符数组和字符指针的联系 
*/ 
#include <stdio.h> 
int main() 
{ 
// 使用两种方式定义字符串 
char str1[] = "你好，马杰克！"; 
char *str2 = "您好，马应龙！"; 
// 测试赋值 
// str1 = "你好,龙瑞！"; // 不能对字符数组整体赋值，如果要赋值，请使用string.h中strcpy() 
str2 = "你好,药可！"; 
// 打印输出 
printf("%s\n%s\n",str1,str2); 
char a[] = "I love you!"; 
char *b = "I love you!"; 
// 使用下标法和指针法访问字符串 
printf("%c\n%c\n",a[4],*(b+4));// v v 空格也是占位的 
return 0; 
} 

字符串作为形式参数

• 实参与形参都可以是字符数组
• 实参用字符数组，形参用字符指针（在函数内部不能对字符串中的字符做修改

  • test5(char *arr,int len) 
    { 
    arr[2] = 'A'; // 错误，字符串常量一旦创建，就不能被改变 
    }
    main(){ 
    char arr[] = "abc"; // 字符串常量，常量是不可修改的 
    test(arr,3); 
    } 
    

    • 实参和形参都是指针变量（在函数内部不能对字符串中的字符做修改）

    test(char *arr,int len) 
    { 
    arr[2] = 'A'; // 错误 
    }
    main() 
    { 
    char arr[] = "abc"; 
    char *p = arr;// &arr[0] 
    test(p,3); 
    } 
    

    • 实参是指针类型，形参是字符数组

    注意：

            1. 字符数组在创建的时候，会在内存中开辟内存空间，内存空间可以存放字符数据；字符指针在创建的时候，需要依赖于字符数组，字符指针在内存中开辟的内存空间中，存放的是数组元素的内存地址。字符指针的创建依赖于字符数组，字符数组可以独立存在，而字符指针不能独立存在。

            2. 字符数组可以初始化，但是不能赋值；字符指针可以初始化，也可以赋值。

    // 字符数组 
    char str1[11] = "I love You!"; 
    str1 = "Home"; // 错误 
    str1[] = "home"; // 错误 
    // 字符指针 
    char *str2 = "I love You!"; 
    str2 = "home";// 正确 
    

案例1：

/**
* 字符指针作为函数参数：用函数调用实现字符串，复制以及计算字符串长度。 
*/ 
#include <stdio.h> 
/* 定义一个函数，传递拷贝的字符串，返回字符串长度 */ 
int str_copy(char *str1,char *str2) 
{ 
int i = 0; // 循环变量 
while(str1[i]!='\0') 
{ 
// 实现拷贝 
str2[i] = str1[i]; 
i++; 
}
// 拷贝结束之后，一定要给字符串加上结束符号\0 
str2[i] = '\0'; 
return i; 
}
int main() 
{ 
// 定义两个数组，从键盘录入字符串 
char str1[20],str2[20]; 
printf("请输入一个字符串：\n"); 
scanf("%s",str1); 
printf("str1=%s\n",str1); 
int len = str_copy(str1,str2); 
printf("str2=%s\n",str2); 
printf("len=%d\n",len); 
return 0; 
} 

案例2：

/**
* 给定一个字符串，截取start到end之间字符串，含头不含尾 
*/ 
#include <stdio.h> 
/* 字符串截取函数 */ 
int str_split(char *str,int start,int end,char *temp) 
{ 
// 定义一个循环变量 
int i = 0,k = 0; 
// 定义一个字符指针，用来接收str中截取到字符串 
// 循环遍历每一个字符 
while(str[i]!='\0') 
{ 
if(i>= start && i < end) 
{ 
temp[k] = str[i]; 
k++; 
}
i++; 
}
temp[k] = '\0'; 
// 更新str中的数据 
printf("%s\n",temp); 
return k; 
}
int main() 
{ 
char *str = "abcdefg"; 
char temp[100]; 
int len = str_split(str,2,5,temp); 
printf("str=%s,len=%d\n",temp,len); 
return 0; 
} 

函数指针与指针函数

函数指针

• 定义：函数指针本质是指针，它是函数的指针（定义一个指针变量，变量中存储了函数的地址）。函数都有一个入口地址，所谓指向函数的指针，就是指向函数的入口地址。这里函数名就代表入口地址。

• 函数指针存在的意义：

      1. 让函数多了一种 调用方式

        2. 函数指针作为形参，可以形式调用（回调函数）

定义格式：

返回值类型（*变量名）(形式参数列表)；

举例：

int (*p) (int a,int b);

• 函数指针的初始化

1.定义同时赋值

// 得先有函数，才能定义这个函数的指针 
int fun(int a,int b){..} 
// 定义函数指针并给它赋值 
int (*p) (int a,int b) = fun;// fun不能跟() 

2. 先定义后赋值

// 得先有函数，才能定义这个函数的指针 
float fun(int a,double b,char c){..} 
// 先定义函数指针 
float (*p) (int a,double b,char c); 
// 赋值 
p = fun; 

总结：

1. 函数指针指向的函数要和函数指针定义的返回值类型，形参列表对应，否则编译报错

2. 函数指针是指针，但不能指针运算，如 p++ 等，没有实际意义。

3. 函数指针作为形参，可以形成回调（回调后面讲）。

4. 函数指针作为形参，函数调用时的实参只能是与之对应的函数名，不能带小括号。

5. 函数指针的形参列表中的变量名可以省略。

案例：

/**
* 函数指针：指向函数的指针变量就是函数指针 
需求：求a，b两个数的最大值 
*/ 
#include <stdio.h> 
int max(int a,int b) 
{ 
if(a > b) 
{ 
return a; 
}
return b; 
}
int main() 
{ 
int a = 3,b = 2,c; 
// 普通函数调用 
c = max(a,b); 
printf("%d,%d两个数中的最大值是：%d\n",a,b,c); 
// 通过指针变量访问它指向的函数 
// 创建指针并初始化 
int (*p)(int,int) = max; 
// 调用函数指针 
c = p(a,b); 
printf("%d,%d两个数中的最大值是：%d\n",a,b,c); 
// 调用函数指针 
c = (*p)(a,b); 
printf("%d,%d两个数中的最大值是：%d\n",a,b,c); 
return 0; 
}

指针函数

• 定义：本质是函数，这个函数的返回值类型是指针，这个函数称为指针函数。
• 定义格式

指针类型 函数名(形参列表)
 { 
函数体; 
return 指针变量;
 }

举例：

int *get(int a)
 { 
int *b = &a; 
// return &a; // 编译报警告 
return b;
 }

注意：

        在函数中不要直接返回一个局部变量的地址，因为函数调用完毕后，局部变量会被回收，使

得返回的地址就不明确，此时返回的指针就是野指针。

解决方案：

        如果非要访问，可以给这个局部变量添加 static ，可以延长它的生命周期，从二避免野指针

（尽量少用，因为存在内存泄漏）。

案例：

/**
* 指针函数：函数的返回值是指针类型 
需求：有若干个学生的成绩（每个学生有４门课程），要求在用户输入学生序号以后，能输出该学生的全部成绩。用 
指针函数来实现。 
*/ 
#include <stdio.h> 
/* 定义一个函数，传入学生的序号，返回这个学生的所有课程成绩 */ 
float *search(float (*p)[4],int n) 
{ 
// 定义一个指针，用来接收查询到的某个学生的所有课程 
float *pt; 
pt = *(p+n);// p[n] 
return pt; 
}
int main() 
{ 
// 准备所有学生的成绩 
float score[][4]={{60,70,80,90},{56,66,76,76},{35,68,90,37}}; 
int i,m; 
float *p; 
printf("请输入学生序号(0~2)：\n"); 
scanf("%d",&m); 
printf("第%d个学生的成绩：\n",m); 
p = search(score,m);// 函数返回值为行的首地址 
// 遍历 
for(i = 0; i < 4;i++) 
printf("%5.2f\t",*(p+i)); 
printf("\n"); 
return 0; 
} 

野指针、空指针

野指针

• 定义：访问了一个已经销毁或者访问受限的内存区域外的指针，这个指针就是野指针。
• 野指针产生的场景：

1.变量未初始化，通过指针访问该变量

int a;
int *p = &a;// p就是野指针

ptf(*p); // 访问野指针，但是数据不安全

2.指针变量未初始化

int *p = NULL; //此时P也是野指针
ptf (*p);

3.指针指向的内存空间被（free函数）回收了

4.指针函数中直接返回了局部变量的地址。

5.指针指向数组以外的地址（下标越界）

• 如何避免野指针：

写代码要养成两个习惯（通过编码规范避免）

1.指针变量要及时初始化，如果暂时没有对应的值，建议赋值为NULL；

2.数组操作（遍历，指针运算）时，注意数组的长度，避免越界

3.指针指向的内存空间被回收，建议给这个指针变量赋值为NULL;

int *p = (int*)malloc(10);//动态内存分配
free(p);//动态内存释放
p = NULL;p不指向任何空间

4.指针变量使用之前要检查他的有效性（以后开发中要做非空校验）

int *p = NULL;
if(!p)
{
return -1;
}

说明：NULL是空常量，它的值是0，这个NULL一般存放在内存中的0x00000000位置，这个地址只能存放NULL，不能被其它程序修改。

空指针

空指针，又称为悬空指针：当一个指针的值是NULL，这个指针被称为空指针；对空指针访问会运行报错（段错误）

二极指针

定义:二极指针，又被称作多重指针，引用以及指针的地址，此时这个指针变量就得定义成二极指针

int a = 10;
int *p = &a;
int **w = &p;

定义格式：

数据类型 **变量名 = 指针数组的数组名或者一级指针的地址

//指针数组
int array = {1,2,3};
int *arr = {&array[0],&array[1],&array[2]};

//一级指针
int a = 10;
int *p = &a;//一级指针

举例：

//字符型指针数组
char *arr[3] = {"abc","aaa034"."12a12"};//等效与 char arr[3][6]= {"abc","aaa034","12a12"}
//定义二极指针并赋值(指针需要跟依赖的源同类型)
char **p = arr;

int a = 90;
int *p = &a;//一级指针
int **k = &p; //二极指针

结论：

1.二级指针和指针数组是等效的，和二维数组不等效

2.二维数组和数组指针是等效的,和二级指针不等效

二级指针的用法：

1.如果是字符的二级指针，可以像遍历字符串数组一样遍历它

2.如果是其他的二级指针，就需要解引用两次访问它所指向的数据

案例：

/**
* 二级指针案例：使用指向指针数据的指针变量。 
*/ 
#include <stdio.h> 
void fun1() 
{ 
char *name[]={"Follow me","BASIC","Great Wall","FORTRAN","Computer design"}; 
// 定义一个二级指针 
char **p; 
// 定义循环变量 
int i = 0; 
// 遍历指针数组 
do
{ 
p = name + i; 
printf("%s\n",*p); 
i++; 
}while(i < 5); 
printf("\n"); 
}
void fun2() 
{ 
int arr1[5] = {11,12,13,14,15}; 
// 创建一个指针数组 
int *arr[] = {&arr1[0],&arr1[1],&arr1[2],&arr1[3],&arr1[4]}; 
int **p = arr,i = 0; 
// 遍历 
for(;i < 5; i++) 
{ 
// printf("%5d",**(p+i)); 
printf("%5d",**p); 
p++; 
}
printf("\n"); 
}
int main() 
{ 
fun1(); 
fun2(); 
} 

• main函数的原型

• 定义：main函数有多种定义格式，main函数也是函数，函数相关的结论对main函数也有效（也可以定义main函数的函数指针）。
• main函数的完整写法：

int main(int argc,char *argv[]){} 
int main(int argc,char **argv){}

• 扩展写法

int main(){} 
int main(void){} 
void main(){} 
main(){} ---- int main(){} 
void main(void){} 
int main(int a){} 
int main(int a,int b,int c){} 
... 

说明：

        1. argc， argv 是形参的名称，它们俩可以修改

        2. main函数的扩展写法有些编译器不支持，编译报警告

        3. argc和 argv 的常规写法：

•          argc：存储了参数的个数
  • argv：存储了所有参数的字符串形式

4. main 函数是系统通过函数指针的回调形式调用的

• 注意：如果一个函数没有写返回值类型，这个函数的默认返回类型是int。

案例：

/**
* main函数 
*/ 
#include "stdio.h" 
int main(int argc,char **argv) 
{ 
int k; 
for (k=1;k < argc;k++) 
printf("%s\n",argv[k]); 
} 

常量指针与指针常量

常量：分为字面量和只读常量，字面量（就是我们平时直接操作的如：printf("12")|printf("hello");只读常量使用关键字const修饰，凡是被这个关键字修饰的变量，一旦赋值，值就不能改变

语法：

//字面常量举例,字面常量是一种匿名的常量
printf（12）；
printf（"请输入一个数：\n"）;

//只读常量
const int a = 10;
a = 21;//编译错误，因为此时这个变量是只读常量，所以不可更改其值

常量指针

定义：常量的指针，本质是一个指针，指针指向的数据不能改变

定义格式：

const 数据类型 *变量名；

举例：

const int *p; //p就是常量指针

结论：

1.常量指针指向的数据不能改变（不能解引用间接修改数据）

2.常量指针的地址可以改变

应用场景：作为形式参数，实际参数需要给一个常量。

案列：

#include <stdio.h> 
/* 常量指针 */ 
void test1() 
{ 
// 定义变量 
int a = 10; 
// 定义常量指针 
const int *p = &a; 
// *p = 100; // 编译报错，常量的值不能修改（常量指针指向地址空间的数值不能修改） 
printf("%d\n",*p);// 10 
int b = 90; 
p = &b; // 编译通过，常量的地址可以修改（常量指针指向的地址空间可以发生改变） 
printf("%d\n",*p);// 90 
}
int main() 
{ 
test1(); 
} 

指针常量

定义：指针的常量，指针的指向不能改变

定义格式：

数据类型 *const 变量名；

举例：

int* const p;//指针常量

结论：

1.指针常量的指向不能被改变（不能给指针变量重新赋地址值）

2.指针常量指向的数据可以改变

注意：指针常量在定义时就要赋值；不能先定义后赋值，否则编译报错

案例：

/**
* 常量指针与指针常量 
*/ 
#include <stdio.h> 
/* 指针常量 */ 
void test2() 
{ 
// 定义变量 
int a = 10; 
// 定义指针变量 
int* const p = &a; 
// 错误写法：先定义，后赋值（编译报错） 
// int* const p; 
// p = &a; 
// 间接取数据 
pirntf("%d\n",*p); 
// int b = 200; 
// p = &b;// 编译报错，地址不能改变 
*p = 200; 
printf("%d\n",*p);// 200 
}
int main() 
{ 
test2(); 
} 

常量指针常量

• 定义语法：

 const 数据类型* const 变量名;

举例：

 const int* const p; // 常量指针常量

作用： p 的指向不能被改动（地址）， p 指向的数据不能被改（地址对应内存中存放的数据）

动态内存分配

我们要想实现动态内存分配，就需要学习标准 C 提供的函数库：

1. 函数所属的库文件

2. 函数的原型 - 函数的声明

        1. 函数名

        2. 形参

        3. 返回值类型

3. 函数的功能

注意：内存分配函数在申请内存时，建议用多少申请多少，可以有少量的预留量；但不能越界访问

（虽然编译和运行不报错，但数据不安全）

常用函数

malloc

• 头文件： #include <stdlib.h>
• 函数功能：C 库函数 void *malloc(size_t size) 分配所需的内存空间，并返回一个指向它的指 针。
• 函数原型:

• 函数名：malloc
• 形式参数：size_t size：内存块的大小，以字节为单位。本质上就是一个 unsigned int 返回值类型：void* ：该函数返回一个指针，指向已分配大小的内存，如果请求失败，返回 NULL。
• 举例：

 int *p = (int*)malloc(4);

• 说明：

        1. malloc函数分配的内存没有默认值，是不确定数，大概率是 0 ；

        2. malloc函数申请的内存空间连续。

calloc

• 头文件： #include <stdlib.h>
• 函数功能：C库函数 void * calloc(size_t nitems,size_t size) 分配所需的内存空间，并返回一 个指向它的指针。

                malloc和calloc 之间不同点事， malloc 不会设置内存为零，而 calloc 会设置内存为零。

• 函数原型： void *calloc(size_t nitems,size_t size)
• 函数名：calloc
• 形式参数：
  • size_t nitems：申请多少个
  • size_t size：一个占几个内存单元（一个内存单元 等于 一个字节）
• 返回值类型：void*：该函数返回一个指针，指向已分配大小的内存。如果请求失败，返回NULL.
• 举例：

int *p = (int*)calloc(3,4); // p指向的空间的大小是12个字节 
if(!p) printf("内存申请失败！\n");

• 说明：

1. calloc 函数分配的内存有默认值，每个内存单元都是 0

2. calloc 函数申请的内存空间连续

3. calloc 大多时候为数组中的元素申请内存

     转存栈中数组中的数据：

int arr[3] = {10,20,30}; // 在栈区 
int *p = (int*)calloc(3,4); // 申请内存，在堆区 
if(!p) puts("内存申请失败！"); 
// 转存 
for(int i = 0;i < 3; i++) 
p[i] = arr[i]; 
// 遍历 
for(int i = 0;i < 3; i++) 
printf("%d,",p[i]); 
printf("\n"); 
// p使用完，记得释放内存 
free(p); 
p = NULL; // 内存回收后，建议置空 

realloc

• 头文件： #include <stdlib.h>
• 函数功能：尝试重新调整之前调用malloc或calloc所分配的ptr所指向的内存块的大小。
• 函数原型： void *realloc(void *ptr,size_t size)
• 函数名：realloc
• 形式参数：
  • void *ptr：是malloc或者calloc的返回值
  • size_t size：重新分配后的内存大小
• 返回值：void*：该函数返回一个指针，指向已分配大小的内存。如果请求失败，返回NULL。

案例：

int *p = (int*)malloc(4); 
int *w = (int*)realloc(p,20); 
// int *q = (int*)realloc(p,0); // 等效于free(p) 12

说明：

1. realloc 以原来 malloc 返回的内存地址开始，分配总共 20 个字节的内存空间

2. 如果原来的内存空间后有 20 个连续空间，就扩容 20-4 =16 个内存单元，返回原来旧的内存首地

址。

3. 如果原来的内存空间后不够 20 个连续内存空间，就重新找一个内存地址开始，申请 20 个内存

单元。并将原来的数据拷贝到新的内存中，回收旧的内存单元，并返回新的内存首地址。

free

• 头文件： #include <stdlib.h>
• 函数功能：释放之前调用 malloc、calloc、realloc所分配的内存空间，是访问完记得使用NULL置空。
• 函数原型： void free(void *ptr)
  • 函数名：free
• 形式参数：
• void *ptr：calloc,malloc.realloc的返回值
• 返回值类型：void：没有返回值
• 注意：

        1. 堆内存中的指针才需要回收，栈中系统会自动回收

        2. 堆内存不能重复回收，运行会报错

说明：

1. 堆的内存空间相比较栈要大很多

2. 内存分配函数返回的指针变量可以参与运算（只读），但不能被修改（ p++ 或者 p+=i 是错误的）

 void与void*的区别

• 定义：
  • void：是空类型，是数据类型的一种
  • void*：是指针类型，是指针类型的一种，可以匹配任意类型的指针，类似于通配符
• void
  • 说明：void作为返回值类型使用，表示没有返回值；作为形参，表示形参列表为空，在调用函数是不能给实参
  • 举例：

// 函数声明 
void fun(void); // 等效于 void fun(); 
// 函数调用 
fun(); 

• void*
  • 说明：
    • void*是一个指针类型，但该指针的数据类型不明确，无法通过解引用获取 内存中的数据， 因为 void* 不知道访问几个内存单元。
    • void*是一种数据类型，可以作为函数返回值类型，也可以作为形参类型
    • void*类型的变量在使用之前必须强制类型转换，明确它能够访问几个字节的内存空间

int *p = (int*)malloc(4);
 double *p2 = (double*)malloc(8);

• 举例：

#include <stdio.h> 
#include <stdlib.h> 
// 函数定义 
void* fun(void* p) // 指针函数（返回值类型是指针的函数，此时返回的是不明确类型，需要外部强转） 
{ 
int *p; 
// double *p; 
// long *p; 
// char *p; 
return p; 
}
// 函数调用 
void main() 
{ 
int *p; 
void* a = fun(p);// 这种接收方式，实际上没有意义 
printf("%p\n",a);// 可以正常打印，打印出一个地址 
*a = 10;// 编译报错，void*变量不能解引用访问数据 
int *w = (int*)a; 
*w = 10;// 编译和运行正常，void*变量a在使用前已经强制类型转换了，数据类型明确了，访问的内存 
单元明确了。 

• 说明：
  • void*作为返回值类型：这个函数可以返回任意类型（ char*,int*,double*等 ）的指针。
  • void*作为形参类型：这个函数在调用时，可以给任意类型（ char*,int*,double*等 ）的指 针。
• 总结：
  • void* 类似于通配符，不能对void*类型的变量解引用（因为不明确内存单元的大小）。
  • void* 在间接访问（解引用）前要强制类型转换，但不能太随意，否则存和去的数据类型不 一致。

内存操作

我们对于内存的操作借助于string.h这个库提供的内存操作函数。

内存填充

• 头文件：#include <string.h>
• 函数原型：void *memset(void *s,int c,size_t n);
• 函数功能：填充s开始的堆内存空间前n个字节，使得每个字节值为c
• 函数参数：
  • void *s:待操作内存的首地址
  • int c：填充的字节数据
  • size_t n：填充的字节数
• ​​​​​​​返回值：返回s
• 注意：c常常设置为0，用于动态内存填充

内存拷贝

• 头文件：#include <string.h>
• 函数原型：void *memcpy(void *dest,const void *src,size_t n);适合目标地址与源地址内存无重叠的情况

                        void *memmove(void *dest,const void *src,size_t n);

• 函数功能：拷贝src开始的堆内存空间前n个字节，到dest对应的内存中
• 函数参数：
  • ​​​​​​​void *dest:目标内存的首地址
  • void *src：源内存首地址
  • size_t n：拷贝的字节数
• ​​​​​​​返回值：返回dest
• 注意：内存申请了几个内存空间，就访问几个内存空间，否则数据不安全
• 注意：memcpy与memmove一般情况下是一样的，更建议使用memmove进行内存拷贝；因为memmove函数是从自适应（从前往后或者从后往前）拷贝，当被拷贝的内存和目的地的内存有重叠时，数据不会出现拷贝错误。而memcpy函数是从前往后拷贝，当被拷贝的内存有重叠时，数据会出现拷贝错误。

案例：

/**
* 内存操作函数-memcpy|memmove 
*/ 
#include <stdio.h> 
#include <stdlib.h> 
#include <string.h> 
void test1() 
{ 
// 申请内存 
// int *p1 = (int*)malloc(4 * sizeof(int)); 
// int *p2 = (int*)malloc(6 * sizeof(int)); 
// 给p1,p2填充数据，可以使用for循环.. 
// for(int i = 0; i < 4; i++) 
// p1[i] = 10 + i; 
// memset(p2,0,6 * sizeof(int)); 
// 创建数组 
int p1[4] = {11,12,13,14}; 
int p2[6] = {21,22,23,24,25,26}; 
// 将p1中的数据通过内存拷贝函数，拷贝到p2 
// memcpy(p2+2,p1+1,2*sizeof(int)) // int p2[6] = {21,22,12,13,25,26} 
memmove(p2+2,p1+1,2*sizeof(int)); 
// 测试输出数组 
for(int i = 0; i < 4; i++) 
printf("%4d",p1[i]); 
printf("\n"); 
for(int j = 0; j < 6; j++) 
printf("%4d",p2[j]); 
printf("\n"); 
// 如果使用手动分配的指针，一定要记得释放内存 
// free(p1); 
// free(p2); 
// p1 = NULL; 
// p2 = NULL; 
}
int main() 
{ 
test1(); 
return 0; 
} 

内存比较

• 头文件： #include <string.h>
• 函数原型： int memcmp(void *dest,const void *src,size_t n)
• 函数功能：比较src和dest所代表的内存前n个字节的数据；
• 函数参数：
  • void *dest：目标内存首地址
  • const void* src：源内存首地址
  • size_t n：比较的字节数
• 返回值：

•         0 ：数据相同
  • >0 ：dest中的数据大于src
  • <0 ：dest中的数据小于src
• 注意：n一般和src，dest的总容量一样；如果不一样，内促比较的结果就不确定了。
• 案例：

/**
* 内存操作-memcmp 
*/ 
#include <stdio.h> 
#include <stdlib.h> 
#include <string.h> 
void test1() 
{ 
// 申请内存 
int *p1 = (int*)malloc(3*sizeof(int)); 
int *p2 = (int*)malloc(4*sizeof(int)); 
// int p1[4] = {1,0,3,6}; 
// int p2[4] = {1,2,3,4}; 
// int result = memcmp(p1,p2,4*sizeof(int)); 
*p1 = 65; 
*p2 = 70; 
char *a = (char*)p1;// 类型转换 
char *b = (char*)p2; 
printf("%c,%c\n",*a,*b); 
int result = memcmp(a+1,b+1,1*sizeof(char)); 
printf("%d\n",result); 
}
int main() 
{ 
test1(); 
} 

内存查找

• 头文件： #include <string.h>
• 函数原型： int *memchr|*memrchr(const void *s,int c,size_t n)
• 函数功能：在s开始的堆内存空间前n个字节中查找字节数据c
• 函数参数：
  •         const void *s：待操作内存首地址；
  • int c：待查找的字节数据
  • size_t n：查找的字节数
• 返回值：返回查找到的字节数据地址
• 注意：如果内存中没有重复数据，memchr和memrchr结果是一样的；如果内存中有重复数据， memchr和memrchr结果就不一样；

举例：

void *memrchr(..);// 在使用时编译会报错，需要使用外部声明 
// 外部申请 
extern void *memrchr(..); 

案例：

/**
* 内存操作-memchr | memrchr 
*/ 
#include <stdio.h> 
#include <stdlib.h> 
#include <string.h> 
// 声明外部函数 
extern void *memrchr(const void *s,int c,size_t n); 
void test1() 
{ 
// 申请内存 
int *p = (int*)malloc(4*sizeof(int)); 
if(!p) 
{ 
puts("内存分配失败！"); 
return; 
}
// 给变量赋值 
for(int i = 0; i < 4; i++) 
{ 
p[i] = i * 2; 
}
p[3] = 4; 
// 输出 
for(int i = 0; i < 4; i++) 
{ 
printf("%d,",p[i]); 
}
printf("\n"); 
// 内存查找 memchr 
int *x = (int*)memchr(p,4,4*sizeof(int)); 
printf("%p--%p--%d\n",x,p,*x); 
// 内存查找 memrchr 
int *y = (int*)memrchr(p,4,4*sizeof(int)); 
printf("%p--%p--%d\n",y,p,*y); 
// 回收内存 
free(p); 
p = NULL; 
}
int main() 
{ 
test1(); 
} 

扩展：形式参数和实际参数的对应关系

//形式参数和实际参数的对应关系 
#include <stdio.h> 
//void test(int arr[]) //可以 
//void test(int arr[2]) //可以 
//void test(int * arr) //可以 
//void test(int *arr[]) //不可以，编译报错 
//void test(int ** arr) //不可以 
//void test(int (*arr)[]) //不可以 
//--------------------------------- 
//void test2(int * arr[]) //可以 
//void test2(int ** arr) //可以 
void test2(int (*arr)[]) //不可以 
{ 
printf("test执行了\n"); 
} 
int main() 
{ 
/*
int arr[3]={0}; 
test(arr); 
*/
int *arr[3] = {0}; 
test2(arr); 
return 0; 
} 

扩展：

//形式参数和实际参数的对应关系 
#include <stdio.h> 
//void test(int arr[2][3]) //可以 
//void test(int arr[][3]) //可以 
//void test(int arr[2][]) //不可以 
//void test(int arr[][]) //不可以 
//void test(int (*arr)[]) //可以 
//void test(int(*)arr[]) //语法错误 
//void test(int(*arr)[3]) 
//void test(int *arr[]) //不可以 
//---------------------------------------- 
//void test2(int *arr[]) //可以 
//void test2(int arr[][1]) //不可以 
//void test2(int **arr) //可以 
void test2(int(*arr)[]) //不可以 
{ 
printf("test\n"); 
}
int main() 
{ 
/*
int arr[2][3] = {0}; 
test(arr); 
*/
/*
int a = 20; 
int *arr[] = {&a}; 
test2(arr)
*/
int** p; 
test3(p); 
return 0; 
} 

形式参数和实际参数的对应关系扩展：形式参数和实际参数的对应关系