0
点赞
收藏
分享

微信扫一扫

2022最新C语言指针超详解(大学看这个就够了,0基础也能看懂)


目录

指针

1.关于内存那点事

2.指针的概念

3.指针变量的定义方法

1.简单的指针变量

2.关于指针的运算符

3.指针大小

4.指针的分类

1:字符指针

2:短整型指针

3:整型指针

4:长整型指针

5:float 型的指针

6:double 型的指针

7:函数指针

8、结构体指针

9、指针的指针

10、数组指针

11、通用指针 void *p;

5.指针和变量的关系

6.指针和数组元素之间的关系

数组元素的引用方法

指针的运算

7.指针数组

1、指针和数组的关系

2、指针数组的定义方法:

3、指针数组的分类

8.指针的指针

9.字符串和指针

字符串的概念:

字符串的存储形式: 数组、文字常量区、堆

字符串的可修改性:

10.数组指针

1、二维数组

2、数组指针的概念:

3、数组指针的定义方法:

4、各种数组指针的定义:

5、三维数组指针,加 1 后指向下个三维数组

6、四维数组指针,加 1 后指向下个四维数组,以此类推。。。。

7、注意:

8、数组名字取地址:变成 数组指针

9、数组名字和指针变量的区别:

10、数组指针取*

11.指针和函数的关系

指针作为函数的参数

12.指针作为函数的返回值

13.指针保存函数的地址(函数指针)

1、函数指针的概念:

2、函数指针的用处:

3、函数指针变量的定义

4、调用函数的方法

5、函数指针数组

6、函数指针应用举例

14.经常容易混淆的指针概念

15.特殊指针

1、空类型的指针(void *)

2、NULL

指针

1.关于内存那点事


存储器:存储数据器件



外存


外存又叫外部存储器,长期存放数据,掉电不丢失数据


常见的外存设备:硬盘、 flash 、 rom 、 u 盘、光盘、磁带


内存


内存又叫内部存储器,暂时存放数据,掉电数据丢失


常见的内存设备: ram 、 DDR




2022最新C语言指针超详解(大学看这个就够了,0基础也能看懂)_git


物理内存:实实在在存在的存储设备


虚拟内存:操作系统虚拟出来的内存。







操作系统会在物理内存和虚拟内存之间做映射。






2022最新C语言指针超详解(大学看这个就够了,0基础也能看懂)_git_02




在 32 位系统下,每个进程(运行着的程序)的寻址范围是 4G,0x00 00 00 00 ~0xff ff ff ff


在写应用程序的,咱们看到的都是虚拟地址。


在运行程序的时候,操作系统会将 虚拟内存进行分区。


1.堆


在动态申请内存的时候,在堆里开辟内存。


2.栈


主要存放局部变量(在函数内部,或复合语句内部定义的变量)。


3.静态全局区


1 ):未初始化的静态全局区


静态变量(定义的时候,前面加 static 修饰),或全局变量 ,没有初始化的,存在此区


2 ):初始化的静态全局区


全局变量、静态变量,赋过初值的,存放在此区


4.代码区


存放咱们的程序代码


5.文字常量区


存放常量的。


内存以字节为单位来存储数据的,咱们可以将程序中的虚拟寻址空间,看成一个很大的一维的字符数组


2.指针的概念


系统给虚拟内存的每个存储单元分配了一个编号,从 0x00 00 00 00 ~0xff ff ff ff


这个编号咱们称之为地址


指针就是地址



2022最新C语言指针超详解(大学看这个就够了,0基础也能看懂)_git_03


指针变量:是个变量,是个指针变量,即这个变量用来存放一个地址编号


在 32 位平台下,地址总线是 32 位的,所以地址是 32 位编号,所以指针变量是 32 位的即 4 个字节。


注意: 1 :


无论什么类型的地址,都是存储单元的编号,在 32 位平台下 都是 4 个字节,


即任何类型的指针变量都是 4 个字节大小


2 :对应类型的指针变量,只能存放对应类型的变量的地址


举例:整型的指针变量,只能存放整型变量的地址


扩展


字符变量 char ch= ‘b’ ;


ch 占 1 个字节,它有一个地址编号,这个地址编号就是 ch 的地址


整型变量 int a=0x12 34 56 78; a 占 4 个字节,它占有 4 个字节的存储单元,有 4 个地址编号。



2022最新C语言指针超详解(大学看这个就够了,0基础也能看懂)_c语言_04




3.指针变量的定义方法

1.简单的指针变量


数据类型 * 指针变量名 ;


int * p;// 定义了一个指针变量 p


在 定义指针变量的时候 * 是用来修饰变量的,说明变量 p 是个指针变量。


变量名是 p


2.关于指针的运算符


& 取地址 、 * 取值、


例1:


int a=0x1234abcd;
int *p;
//在定义指针变量的时候*代表修饰的意思,修饰 p 是个指针变量。 
p=&a;
//把 a 的地址给 p 赋值 ,&是取地址符,


p 保存了 a 的地址,也可以说 p 指向了 a


p a 的关系分析: a 的值是 0x1234abcd ,假如 a 的地址是: 0xbf e8 98 68




2022最新C语言指针超详解(大学看这个就够了,0基础也能看懂)_git_05


int num ;


num=*p;



分析:



1 、在调用的时候 * 代表取值得意思 , *p 就相当于 p 指向的变量,即 a ,


2 、故 num=*p 和 num =a 的效果是一样的。


3 、所以说 num 的值为 0x1234abcd 。



扩展:


如果在一行中定义多个指针变量,每个指针变量前面都需要加 * 来修饰


int *p,*q;// 定义了两个整型的指针变量 p 和 q


int * p,q;// 定义了一个整型指针变量 p ,和整型的变量 q


例2:

int main() {
int a= 100, b = 200; 
int *p_1, *p_2 = &b; 
//表示该变量的类型是一个指针变量,指针变量名是 p_1 而不是*p_1. 
//p_1 在定义的时候没有赋初值,p_2 赋了初值
p_1=&a;
//p_1 先定义后赋值 
printf("%d\n", a); printf("%d\n", *p_1);
printf("%d\n", b); printf("%d\n", *p_2);\
return 0;
 }


注意:


在定义 p_1 的时候,因为是个局部变量,局部变量没有赋初值,它的值是随机的, p_1 指向哪里不一定,


所以 p_1 就是个野指针。





3.指针大小


在 32 位系统下,


所有类型的指针都是 4 个字节




例 3:在 32 位系统下,


所有类型的指针都是 4 个字节



#include <stdio.h> 
 
int main(int argc, char *argv[]) 
 
{ 
 
char *p1; 
 
short int *p2; 
 
int *p3; 
 
long int *p4; 
 
float *p5; 
 
double *p6; 
 
printf("%d\n",sizeof(p1)); 
 
printf("%d\n",sizeof(p2)); 
 
printf("%d\n",sizeof(p3)); 
 
printf("%d\n",sizeof(p4)); 
 
printf("%d\n",sizeof(p5)); 
 
printf("%d\n",sizeof(p6)); 
 
return 0; 
 
}




例 4:



#include <stdio.h> 
 
int main(int argc, char *argv[]) 
 
{ 
 
int a=0x1234abcd; 
 
int *p; 
 
p=&a; 
 
printf("&a=%p\n",&a); 
 
printf("p=%p\n",p);
 
return 0; 
 
}









2022最新C语言指针超详解(大学看这个就够了,0基础也能看懂)_c语言_06






4.指针的分类


按指针指向的数据的类型来分


1:字符指针


字符型数据的地址


char *p;// 定义了一个字符指针变量,只能存放字符型数据的地址编号


char ch;


p= &ch;


2:短整型指针


short int *p;// 定义了一个短整型的指针变量 p ,只能存放短整型变量的地址


short int a;


p =&a;


3:整型指针


int *p;// 定义了一个整型的指针变量 p ,只能存放整型变量的地址


int a;


p =&a;


注:多字节变量,占多个存储单元,每个存储单元都有地址编号,


c 语言规定,存储单元编号最小的那个编号,是多字节变量的地址编号。


4:长整型指针


long int *p;// 定义了一个长整型的指针变量 p ,只能存放长整型变量的地址


long int a;


p =&a;


5:float 型的指针


float *p;// 定义了一个 float 型的指针变量 p ,只能存放 float 型变量的地址


float a;


p =&a;


6:double 型的指针


double *p;// 定义了一个 double 型的指针变量 p ,只能存放 double 型变量的地址


double a;


p =&a;


(下面的指针后面会讲)


7:函数指针

8、结构体指针

9、指针的指针

10、数组指针

11、通用指针 void *p;


总结 : 无论什么类型的指针变量,在 32 位系统下,都是 4 个字节。


指针只能存放对应类型的变量的地址编号。


5.指针和变量的关系


指针可以存放变量的地址编号


int a=100;


int *p;


p=&a;


在程序中,引用变量的方法


1: 直接通过变量的名称


int a;


a=100;


2: 可以通过指针变量来引用变量


int *p;// 在定义的时候, * 不是取值的意思,而是修饰的意思,修饰 p 是个指针变量


p=&a;// 取 a 的地址给 p 赋值, p 保存了 a 的地址,也可以说 p 指向了 a


*p= 100;// 在调用的时候 * 是取值的意思, * 指针变量 等价于指针指向的变量


注:指针变量在定义的时候可以初始化


int a;


int *p=&a;// 用 a 的地址,给 p 赋值,因为 p 是指针变量


指针就是用来存放变量的地址的。


*+ 指针变量 就相当于指针指向的变量


例 5:


#include <stdio.h> 
   
    

    int main() 
   
    

    { 
   
    

    int *p1,*p2,temp,a,b; 
   
    

    p1=&a; 
   
    

    p2=&b; 
   
    

    printf("请输入:a b 的值:\n"); 
   
    

    scanf_s("%d %d",p1,p2);//给 p1 和 p2 指向的变量赋值 
   
    

    temp = *p1; //用 p1 指向的变量(
    a)给 temp 赋值 
   
    

    *p1 = *p2; //用 p2 指向的变量(
    b)给 p1 指向的变量(
    a)赋值 
   
    

    *p2 = temp;//temp 给 p2 指向的变量(
    b)赋值 
   
    

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

    printf("*p1=%d *p2=%d\n",*p1,*p2); 
   
    

    return 0; 
   
    

    }

运行结果:


输入 100 200


输出结果为:


a=200 b=100


*p1=200 *p2=100


扩展:


对应类型的指针,只能保存对应类型数据的地址,


如果想让不同类型的指针相互赋值的时候,需要强制类型转换


void * p;


例 6:


#include <stdio.h> 
    
int main() 
    
{ 
    
int a=0x12345678,b=0xabcdef66; 
    
char *p1,*p2; 
    
printf("%0x %0x\n",a,b); 
    
p1=(char *)&a; 
    
p2=(char *)&b;
    
p1++; 
     
p2++; 
     
printf("%0x %0x\n",*p1,*p2); 
     
return 0; 
     
}



2022最新C语言指针超详解(大学看这个就够了,0基础也能看懂)_开发语言_07


结果为:


0x 78 0x66


0x56 0xef


注意:


1 : *+ 指针 取值,取几个字节,由指针类型决定的指针为字符指针则取一个字节,


指针为整型指针则取 4 个字节,指针为 double 型指针则取 8 个字节。


2 :指针 ++ 指向下个对应类型的数据


字符指针 ++ ,指向下个字符数据,指针存放的地址编号加 1


整型指针 ++, 指向下个整型数据,指针存放的地址编号加 4


6.指针和数组元素之间的关系


变量存放在内存中,有地址编号,咱们定义的数组,是多个相同类型的变量的集合,


每个变量都占内存空间,都有地址编号


指针变量当然可以存放数组元素的地址。


例 7:


int a[5]; 
    
//int *p =&a[0]; 
    
int *p; 
    
p=&a[0];// 指针变量 p 保存了数组 a 中第 0 个元素的地址,即 a[0]的地址



2022最新C语言指针超详解(大学看这个就够了,0基础也能看懂)_开发语言_08


数组元素的引用方法


方法 1: 数组名 [ 下标 ]


int a[5];


a[2]=100;


方法 2 :指针名加下标


int a[5];


int *p;


p=a;


p[2]=100;// 相当于 a[2]=100;


补充: c 语言规定:数组的名字就是数组的首地址,即第 0 个元素的地址,就是 &a[0] ,是个常量。


注意: p 和 a 的不同, p 是指针变量,而 a 是个常量。所以可以用等号给 p 赋值,但不能给 a 赋值。


p=&a[3];// 正确


a=&a[3];// 错误


方法 3 :通过指针变量运算加取值的方法来引用数组的元素


int a[5];


int *p;


p=a;


*(p+2)=100;// 也是可以的,相当于 a[2]=100


解释: p 是第 0 个元素的地址, p+2 是 a[2] 这个元素的地址。


对第二个元素的地址取值,即 a[2]


方法 4 :通过数组名 + 取值的方法引用数组的元素


int a[5];


*(a+2)=100;// 也是可以的,相当于 a[2]=100;


注意: a+2 是 a[2] 的地址。这个地方并没有给 a 赋值。


例 8:


#include <stdio.h> 
     
int main(int argc, char *argv[]) 
     
{ 
     
int a[5]={0,1,2,3,4}; 
     
int *p; 
     
p=a; 
     
printf("a[2]=%d\n",a[2]); 
     
printf("p[2]=%d\n",p[2]); 
     
printf("*(p+2)%d\n",*(p+2)); 
     
printf("*(a+2)%d\n",*(a+2)); 
     
printf("p=%p\n",p); 
     
printf("p+2=%p\n",p+2); 
     
return 0;


}


指针的运算


1 :指针可以加一个整数 , 往下指几个它指向的变量,结果还是个地址


前提:指针指向数组元素的时候,加一个整数才有意义


例 9:


int a[5]; 
    
int *p; 
    
p=a; 
    
p+2;//p 是 a[0]的地址,p+2 是&a[2]


假如 p 保存的地址编号是 2000 的话, p+2 代表的地址编号是 2008


例 10:


char buf[5]; 
     
char *q; 
     
q=buf; 
     
q+2 //相当于&buf [2]


假如: q 中存放的地址编号是 2000 的话, q+2 代表的地址编号是 2002


2 :两个相同类型指针可以比较大小


前提: 只有两个 相同类型的指针 指向 同一个数组的元素 的时候,比较大小才有意义


指向前面元素的指针 小于 指向后面 元素的指针


例 11:


#include <stdio.h> 
        
int main(int argc, char *argv[]) 
        
{ 
        
int a[10]; 
        
int *p,*q,n;//如果在一行上定义多个指针变量的,每个变量名前面加* 
        
//上边一行定义了两个指针 p 和 q ,定义了一个整型的变量 n 
        
p=&a[1]; 
        
q=&a[6]; 
        
if(p<q) 
        
{ 
        
printf("p<q\n"); 
        
}
        
else if(p>q) 
        
{ 
        
printf("p>q\n"); 
        
}
        
else 
        
{ 
        
printf("p == q\n"); 
        
}
        
return 0; 
        
}


结果是 p<q


3. 两个相同类型的指针可以做减法


前提: 必须是 两个相同类型的指针 指向 同一个数组的元素 的时候,做减法才有意义


做减法的结果是,两个指针指向的中间有多少个元素


例 12:


#include <stdio.h> 
           
int main(int argc, char *argv[]) 
           
{ 
           
int a[5]; 
           
int *p,*q; 
           
p=&a[0]; 
           
q=&a[3]; 
           
printf("%d\n",q-p); 
           
return 0; 
           
}


结果是 3


4 :两个相同类型的指针可以相互赋值


注意 : 只有相同类型的指针才可以相互赋值(


void * 类型的除外)


int *p;


int *q;


int a;


p=&a;//p 保存 a 的地址, p 指向了变量 a


q=p; // 用 p 给 q 赋值, q 也保存了 a 的地址,指向 a


注意:如果类型不相同的指针要想相互赋值,必须进行强制类型转换


注意: c 语言规定数组的名字,就是数组的首地址,就是数组第 0 个元素的地址,是个常量


int *p;


int a[5];


p=a; p=&a[0]; 这两种赋值方法是等价的


7.指针数组

1、指针和数组的关系


1 :指针可以保存数组元素的地址


2 :可以定义一个数组,数组中有 若干个相同类型指针变量 ,这个数组被称为指针数组 int *p[5]


指针数组的概念:


指针数组本身是个数组,是个指针数组 ,是若干个相同类型的指针变量构成的集合


2、指针数组的定义方法:


类型说明符 * 数组名 [ 元素个数 ];


int * p[5];// 定义了一个整型的指针数组 p ,有 5 个元素 p[0]~p[4],


每个元素都是 int * 类型的变量


int a;


p[0]=&a;


int b[10];


p[1]=&b[5];


p[2] 、 *(p+2) 是等价的,都是指针数组中的第 2 个元素。


例 13:


#include <stdio.h> 
             
int main(int argc, char *argv[]) 
             
{ 
             
char *name[5] = {"hello","China","beijing","project","Computer"}; 
             
int i; 
             
for(i=0;i<5;i++) 
             
{ 
             
printf("%s\n",name[i]); 
             
}
             
return 0; 
             
}



2022最新C语言指针超详解(大学看这个就够了,0基础也能看懂)_c语言_09


“hello” 、“ China ”“


beijing ” “


project ” “


computer ” 这 5 个字符串存放在文字常量区。


假设:


“ hello ”首地址是 0x00002000


“ China ”首地址是 0x00003000



beijing ”首地址是 0x00004000



project ”首地址是 0x00005000


“ Computer ”首地址是 0x00006000


则:


name[0] 中存放内容为 0x00002000


name[1] 中存放内容为 0x00003000


name[2] 中存放内容为 0x00004000


name[3] 中存放内容为 0x00005000


name[4] 中存放内容为 0x00006000



2022最新C语言指针超详解(大学看这个就够了,0基础也能看懂)_c语言_10


3、指针数组的分类


字符指针数组 char *p[10] 、短整型指针数组、整型的指针数组、长整型的指针数组


float 型的指针数组、 double 型的指针数组


结构体指针数组、函数指针数组


8.指针的指针


指针的指针,即指针的地址,


咱们定义一个指针变量本身指针变量占 4 个字节,指针变量也有地址编号。


例:


int a=0x12345678 ;


假如: a 的地址是 0x00002000


int *p;


p =&a;


则 p 中存放的是 a 的地址编号即 0x00002000


因为 p 也占 4 个自己内存,也有它自己的地址编号,及指针变量的地址,即指针的指针。


假如:指针变量 p 的地址编号是 0x00003000 ,这个地址编号就是指针的地址


我们定义一个变量存放 p 的地址编号,这个变量就是指针的指针


int **q;


q=&p;//q 保存了 p 的地址,也可以说 q 指向了 p


则 q 里存放的就是 0x00003000


int ***m;


m=&q;



2022最新C语言指针超详解(大学看这个就够了,0基础也能看懂)_java_11


p q m 都是指针变量,都占 4 个字节,都存放地址编号,只不过类型不一样而已

9.字符串和指针

字符串的概念:


字符串就是以 ’\0’ 结尾的若干的字符的集合:比如“


helloworld ”。


字符串的地址,是第一个字符的地址。如:字符串“


helloworld ”的地址,其实是字符串中字符 ’h’ 的地址。


我们可以定义一个字符指针变量保存字符串的地址 , 比如: char *s =”helloworld”;


字符串的存储形式: 数组、文字常量区、堆


1、 字符串存放在数组中


其实就是在内存(栈、静态全局区)中开辟了一段空间存放字符串。


char string[100] = “I love C!”


定义了一个字符数组 string, 用来存放多个字符,并且用 ”I love C!” 给 string 数组初始化 ,


字符串“I love C!”存放在 string 中。


注: 普通全局数组,内存分配在静态全局区


普通局部数组,内存分配在栈区。


静态数组(静态全局数组、静态局部数组),内存分配在静态全局区


2、 字符串存放在文字常量区


在文字常量区开辟了一段空间存放字符串,将字符串的 首地址 付给指针变量。


char *str = “I love C!”


定义了一个指针变量 str, 只能存放字符地址编号,


I love C ! 这个字符串中的字符不是存放在 str 指针变量中。


str 只是存放了字符 I 的地址编号,“


I love C !”存放在文字常量区


3、 字符串存放在堆区


使用 malloc 等函数在堆区申请空间,将字符串拷贝到堆区。


char *str =(char*)malloc(10);// 动态申请了 10 个字节的存储空间,


首地址给 str 赋值。


strcpy(str,"I love C") ; // 将字符串“I


love C! ”拷贝到 str 指向的内存里


字符串的可修改性:


字符串内容是否可以修改,取决于字符串存放在哪里


1. 存放在数组中的字符串的内容是可修改的


char str[100]=”I love C!”;


str[0]= ‘y’ ;// 正确可以修改的


注:数组没有用 const 修饰


2. 文字常量区里的内容是不可修改的


char *str=”I love C!”;


*str =’y’;// 错误, I 存放在文字常量区,不可修改


注:


1 、 str 指向文字常量区的时候,它指向的内存的内容不可被修改。


2 、 str 是指针变量可以指向别的地方,即可以给 str 重新赋值,让它指向别的地方。


3. 堆区的内容是可以修改的


char *str =(char*)malloc(10);


strcpy(str,"I love C");


*str=’y’;// 正确,可以,因为堆区内容是可修改的


注:


1 、 str 指向堆区的时候, str 指向的内存内容是可以被修改的。


2 、 str 是指针变量,也可以指向别的地方。即可以给 str 重新赋值,让它指向别的地方


注意: str 指针指向的内存能不能被修改,要看 str 指向哪里。


str 指向文字常量区的时候,内存里的内容不可修改


str 指向数组(非 const 修饰)、堆区的时候,它指向内存的内容是可以修改


初始化:


1. 字符数组初始化:


char buf_aver[20]="hello world";


2. 指针指向文字常量区,初始化:


char *buf_point="hello world";


3 、指针指向堆区,堆区存放字符串。


不能初始化,只能先给指针赋值,让指针指向堆区,再使用 strcpy 、 scanf 等方法把字符串拷贝到堆区。


char *buf_heap;


buf_heap=(char *)malloc(15);


strcpy(buf_heap,"hello world");


scanf(“%s”,buf_heap);


使用时赋值


1. 字符数组:使用 scanf 或者 strcpy


char buf[20]=”hello world”


buf="hello kitty";


错误 , 因为字符数组的名字是个常量 , 不能用等号给常量赋值。


strcpy(buf,"hello kitty"); 正确,数组中的内容是可以修改的


scanf("%s",buf);


正确,数组中的内容是可以修改的


2. 指针指向文字常量区


char *buf_point = “hello world”;


1) buf_point="hello kitty";


正确 ,buf_point 指向另一个字符串


2) strcpy(buf_point,"hello kitty"); 错误,这种情况, buf_point 指向的是文字常量区,内容只读。


当指针指向文字常量区的时候,不能通过指针修改文字常量区的内容。


3. 指针指向堆区,堆区存放字符串


char *buf_heap;


buf_heap=(char *)malloc(15);


strcpy(buf_heap,"hello world");


scanf(“%s”,buf_heap);


字符串和指针总结:


1 、指针可以指向文字常量区


1 )指针指向的文字常量区的内容不可以修改


2 )指针的指向可以改变,即可以给指针变量重新赋值,指针变量指向别的地方。


2 、指针可以指向堆区


1 )指针指向的堆区的内容可以修改。


2 )指针的指向可以改变,即可以给指针变量重新赋值,指针变量指向别的地方。


3 、指针也可以指向数组(非 const 修饰)


例:


char buf[20]="hello world";


char *str=buf;


这种情况下


1. 可以修改 buf 数组的内容。


2. 可以通过 str 修改 str 指向的内存的内容,即数组 buf 的内容


3. 不能给 buf 赋值 buf= “ hello kitty ”;错误的。


4. 可以给 str 赋值,及 str 指向别处。 str= “


hello kitty ”


10.数组指针

1、二维数组


二维数组,有行,有列。二维数组可以看成有多个一维数组构成的,是多个一维数组的集合,可以认


为二维数组的每一个元素是个一维数组。


例:


int a[3][5];


定义了一个 3 行 5 列的一个二维数组。


可以认为二维数组 a 由 3 个一维数组构成,每个元素是一个一维数组。


回顾:


数组的名字是数组的首地址,是第 0 个元素的地址,是个常量,数组名字加 1 指向下个元素


二维数组 a 中 , a+1 指向下个元素,即下一个一维数组,即下一行。


例 14:


#include <stdio.h> 
              
int main(int argc, char *argv[]) 
              
{ 
              
int a[3][5]; 
              
printf("a=%p\n",a); 
              
printf("a+1=%p\n",a+1); 
              
return 0; 
              
}


2、数组指针的概念:


本身是个指针,指向一个数组,加 1 跳一个数组,即指向下个数组。


3、数组指针的定义方法:


指向的数组的类型(


* 指针变量名) [ 指向的数组的元素个数 ]


int (*p)[5];// 定义了一个数组指针变量 p , p 指向的是整型的有 5 个元素的数组


p+1 往下指 5 个整型,跳过一个有 5 个整型元素的数组。


例 15:


#include<stdio.h> 
              
int main() 
              
{ 
              
int a[3][5];//定义了一个 3 行 5 列的一个二维数组 
              
int(*p)[5];//定义一个数组指针变量 p,p+1 跳一个有 5 个元素的整型数组 
              
printf("a=%p\n",a);//第 0 行的行地址 
              
printf("a+1=%p\n",a+1);//第 1 行的行地址,a 和 a +1 差 20 个字节 
              
p=a; 
              
printf("p=%p\n",p); 
              
printf("p+1=%p\n",p+1);//p+1 跳一个有 5 个整型元素的一维数组 
              
return 0; 
              
}


例 16:数组指针的用法 


#include<stdio.h> 
               
void fun(int(*p)[5],int x,int y) 
               
{ 
               
p[0][1]=101; 
               
}
               
int main() 
               
{ 
               
int i,j; 
               
int a[3][5]; 
               
fun(a,3,5); 
               
for(i=0;i<3;i++) 
               
{ 
               
for(j=0;j<5;j++) 
               
{ 
               
printf("%d ",a[i][j]); 
               
}
               
printf("\n"); 
               
} 
               
}


4、各种数组指针的定义:


(1)、一维数组指针,加 1 后指向下个一维数组


int(*p)[5] ; //


配合每行有 5 个 int 型元素的二维数组来用


int a[3][5] 
              
int b[4][5] 
              
int c[5][5] 
              
int d[6][5] 
              
….. 
              
p=a; 
              
p=b; 
              
p=c; 
              
p=d;


都是可以的 ~~~~


(2)、二维数组指针,加 1 后指向下个二维数组


int(*p)[4][5];


配合三维数组来用,三维数组中由若干个 4 行 5 列二维数组构成


int a[3][4][5];


int b[4][4][5];


int c[5][4][5];


int d[6][4][5];


这些三维数组,有个共同的特点,都是有若干个 4 行 5 的二维数组构成。


p=a;


p=b;


p=c;


p=d;


例 17:


#include<stdio.h> 
                
int main() 
                
{ 
                
int a[3][4][5]; 
                
printf("a=%p\n",a); 
                
printf("a+1=%p\n",a+1);//a 和 a+1 地址编号相差 80 个字节 
                
//验证了 a+1 跳一个 4 行 5 列的一个二维数组 
                
int(*p)[4][5]; 
                
p=a; 
                
printf("p=%p\n",p); 
                
printf("p+1=%p\n",p+1);//p 和 p+1 地址编号相差也 80 个字节 
                
return 0; 
                
}


5、三维数组指针,加 1 后指向下个三维数组


int(*p)[4][5][6];


p+1 跳一个三维数组;


什么样的三维数组啊?


由 4 个 5 行 6 列的二维数组构成的三维数组


配合:


int a[7][4][5][6];


6、四维数组指针,加 1 后指向下个四维数组,以此类推。。。。


7、注意:


容易混淆的概念:


指针 数组 :是个数组,有若干个相同类型的指针构成的集合


int *p[10];


数组 p 有 10 个 int * 类型的指针变量构成,分别是 p[0] ~p[9]


数组 指针 :本身是个指针,指向一个数组,加 1 跳一个数组


int (*p)[10];


P 是个指针, p 是个数组指针, p 加 1 指向下个数组,跳 10 个整形。


指针的 指针 :


int **p;//p 是指针的指针


int *q;


p=&q;


8、数组名字取地址:变成 数组指针


一维数组名字取地址,变成一维数组指针,即加 1 跳一个一维数组


int a[10];


a+1 跳一个整型元素,是 a[1] 的地址


a 和 a+1 相差一个元素, 4 个字节


&a 就变成了一个一维数组指针 , 是 int(*p)[10] 类型的。


(&a) +1 和 &a 相差一个数组即 10 个元素即 40 个字节。


例 18:


#include<stdio.h> 
                    
int main() 
                    
{ 
                    
int a[10]; 
                    
printf("a=%p\n",a); 
                    
printf("a+1=%p\n",a+1); 
                    
printf("&a=%p\n",&a); 
                    
printf("&a +1=%p\n",&a+1); 
                    
return 0; 
                    
}


a 是个 int * 类型的指针,是 a[0] 的地址。


&a 变成了数组指针,加 1 跳一个 10 个元素的整型一维数组


在运行程序时,大家会发现 a 和 &a 所代表的地址编号是一样的,即他们指向同一个存储单元,但是 a


和 &a 的指针类型不同。


例 19:


int a[4][5];


a+1 跳 5 个整型


(&a)+1 跳 4 行 5 列(80 个字节)


总结: c 语言规定,数组名字取地址,变成了数组指针。加 1 跳一个数组。


9、数组名字和指针变量的区别:


int a[5];


int *p;


p=a;


相同点:


a 是数组的名字,是 a[0] 的地址, p=a 即 p 保存了 a[0] 的地址,即 a 和 p 都指向 a[0] ,所以在引用数组


元素的时候, a 和 p 等价


引用数组元素回顾:


a[2] 、 *(a+2) 、 p[2] 、 *(p+2) 都是对数组 a 中 a[2] 元素的引用。


#include<stdio.h> 
                       
int main() 
                       
{ 
                       
int a[5] = { 0,1,2,3,4 }; 
                       
int* p; 
                       
p = a; 
                       
printf("a[2]=%d\n",a[2]); 
                       
printf(" * (a + 2) = % d\n",*(a+2)); 
                       
printf("p[2]=%d\n", p[2]); 
                       
printf(" * (p + 2) = % d\n", *(p + 2)); 
                       
return 0; 
                       
}


不同点:


1 、 a 是常量、 p 是变量


可以用等号 ’=’ 给 p 赋值,但是不能用等号给 a 赋值


2 、 对 a 取地址,和对 p 取地址结果不同


因为 a 是数组的名字,所以对 a 取地址结果为数组指针。


p 是个指针变量,所以对 p 取地址( &p )结果为指针的指针。


例: int a[5]={0,1,2,3,4};


int *p=a;


假如 a[0] 的地址为 0x00002000,p 的地址为 0x00003000



2022最新C语言指针超详解(大学看这个就够了,0基础也能看懂)_java_12



2022最新C语言指针超详解(大学看这个就够了,0基础也能看懂)_开发语言_13


1 、 &p 是指针的指针,为 int ** 类型,结果为 0x00003000 , &p +1 ,往后指向一个 int* 类型的指


针,地址编号差 4


2 、 &a 结果是数组指针,为 int(* )[5] 类型,结果还是 0x00002000 , &a +1 , 往后指一个数组(有 5


个整型元素的一维数组),地址编号差 20


例 20:


#include <stdio.h> 
                         
int main(int argc, char *argv[]) 
                         
{ 
                         
int a[5]; 
                         
int *p; 
                         
p=a;
                        
printf("a=%p\n",a); 
                        
printf("&a=%p\n",&a); 
                        
printf("&a +1 =%p\n",&a +1); 
                        
printf("p=%p\n",p); 
                        
printf("&p=%p\n",&p); 
                        
printf("&p +1=%p\n",&p +1); 
                        
return 0; 
                        
}



10、数组指针取*


数组指针取 * ,并不是取值的意思,而是指针的类型发生变化:


一维数组指针取 * ,结果为它指向的一维数组第 0 个元素的地址,它们还是指向同一个地方。


二维数组指针取 * ,结果为一维数组指针,它们还是指向同一个地方。


三维数组指针取 * ,结果为二维数组指针,它们还是指向同一个地方。


多维以此类推


例 21:


#include<stdio.h> 
                         
int main() 
                         
{ 
                         
int a[3][5]; 
                         
int(*p)[5]; 
                         
p = a; 
                         
printf("a=%p\n", a);//a 是一维数组指针,指向第 0 个一维数组,即第 0 行 
                         
printf("*a=%p\n", *a);//*a 是 第 0 行第 0 个元素的地址,即 &a[0][0] 
                         
printf("*a +1=%p\n", *a + 1);//*a +1 是第 0 行第 1 个元的地址,即&a[0][1] 
                         
printf("p=%p\n",p);//p 是一维数组指针,指向第 0 个一维数组,即第 0 行 
                         
printf("*p=%p\n",*p);//*p 是第 0 行第 0 个元素的地址,即 &a[0][0] 
                         
printf("*p +1=%p\n", *p + 1);//*p +1 是第 0 行第 1 个元的地址,即&a[0][1] 
                         
return 0; 
                         
}


11.指针和函数的关系

指针作为函数的参数

咱们可以给一个函数传一个 整型、字符型、浮点型的数据,也可以


给函数传一个地址。


例:


int num;


scanf("%d",&num);


函数传参:


(1) 、传数值:


例 22:


void swap(int x,int y) 
                            
{ 
                            
int temp; 
                            
temp=x; 
                            
x=y; 
                            
y=temp; 
                            
}
                            
int main() 
                            
{ 
                            
int a=10,b=20; 
                            
swap(a,b); 
                            
printf("a=%d b=%d\n",a,b);//a=10 b=20 
                            
}


实参:调用函数时传的参数。


形参:定义被调函数时,函数名后边括号里的数据


结论:给被调函数传数值,只能改变被调函数形参的值,不能改变主调函数实参的值


(2) 、传地址


例 23:


void swap(int *p1,int *p2) 
                              
{ 
                              
int temp; 
                              
temp= *p1; 
                              
*p1=*p2;// p2 指向的变量的值,给 p1 指向的变量赋值 
                              
*p2=temp; 
                              
}
                              
int main() 
                              
{ 
                              
int a=10,b=20; 
                              
swap(&a,&b); 
                              
printf("a=%d b=%d\n",a,b);//结果为 a=20 b=10 
                              
}


结论:调用函数的时候传变量的地址,在被调函数中通过 *+ 地址来改变主调函数中的变量的值



例 24:


void swap(int *p1,int *p2)//&a &b 
 
{ 
 
int *p; 
 
p=p1; 
 
p1=p2;//p1 =&b 让 p1 指向 main 中的 b 
 
p2=p;//让 p2 指向 main 函数中 a 
 
}//此函数中改变的是 p1 和 p2 的指向,并没有给 main 中的 a 和 b 赋值 
 
int main() 
 
{ 
 
int a=10,b=20; 
 
swap(&a,&b); 
 
printf("a=%d b=%d\n",a,b);//结果为 a=10 b=20 
 
}



总结:要想改变主调函数中变量的值,必须传变量的地址,


而且还得通过 *+ 地址 去赋值 。


例 25:


void fun(char *p) 
   
{ 
   
p="hello kitty"; 
   
}
   
int main() 
   
{ 
   
char *p="hello world"; 
   
fun(p); 
   
printf("%s\n",p);//结果为: hello world 
   
}




答案分析:


在 fun 中改变的是 fun 函数中的局部变量 p ,并没有改变 main 函数中的变量 p ,所以 main 函数中的,


变量 p 还是指向 hello world 。






例 26:


void fun(char **q) 
  
{ 
  
*q="hello kitty"; 
  
}
  
int main() 
   
{ 
   
char *p="hello world"; 
   
fun(&p); 
   
printf("%s\n",p);//结果为:hello kitty 
   
}


总结一句话:要想改变主调函数中变量的值,必须传变量的地址,而且还得通过*+地址 去赋值。无


论这个变量是什么类型的。


(3) 给函数传数组:


给函数传数组的时候,没法一下将数组的内容作为整体传进去。


只能传数组名进去,数组名就是数组的首地址,即只能把数组的地址传进去。


也就是说,只能传一个 4 个字节大小的地址编号进去


例 27:传一维数组的地址


//void fun(int p[])//形式 1 
       
void fun(int *p)//形式 2 
       
{ 
       
printf("%d\n",p[2]); 
       
printf("%d\n",*(p+3)); 
       
}
       
int main() 
       
{ 
       
int a[10]={1,2,3,4,5,6,7,8}; 
       
fun(a); 
       
return 0; 
       
}


例 28:传二维数组的地址


//void fun( int p[][4] )//形式 1 
        
void fun( int (*p)[4] )//形式 2 
        
{
        
}
        
int main() 
        
{ 
        
int a[3][4]={{1,2,3,4},{5,6,7,8},{9,10,11,12}}; 
        
fun(a); 
        
return 0; 
         
}


例 29:传指针数组


void fun(char **q) // char *q[] 
          
{ 
          
int i; 
          
for(i=0;i<3;i++) 
          
printf("%s\n",q[i]); 
          
}
          
int main() 
          
{ 
          
char *p[3]={"hello","world","kitty"}; //p[0] p[1] p[2] char * 
          
fun(p); 
          
return 0;


}


12.指针作为函数的返回值

一个函数可以返回整型数据、字符数据、浮点型的数据,也可以返回一个指针。


例 30:


char * fun() 
          
{ 
          
char str[100]="hello world"; 
          
return str; 
          
}
          
int main() 
          
{ 
          
char *p; 
          
p=fun(); 
          
printf("%s\n",p);// 
          
}
                                        
//           总结:返回地址的时候,地址指向的内存的内容不能释放


如果返回的指针指向的内容已经被释放了,返回这个地址,也没有意义了。


例 31 :返回静态局部数组的地址


char * fun()
           
{ 
            
static char str[100]="hello world"; 
            
return str; 
            
}
            
int main() 
            
{ 
            
char *p; 
            
p=fun(); 
            
printf("%s\n",p);//hello world 
            
}


原因 是,静态数组的内容,在函数结束后,亦然存在。


例 32:返回文字常量区的字符串的地址


char * fun() 
             
{ 
             
char *str="hello world"; 
             
return str; 
             
}
             
int main() 
             
{ 
             
char *p; 
             
p=fun(); 
             
printf("%s\n",p);//hello world 
             
}


原因是文字常量区的内容,一直存在


例 33:返回堆内存的地址


char * fun() 
              
{ 
              
char *str; 
              
str=(char *)malloc(100); 
              
strcpy(str,"hello world"); 
              
return str; 
              
}
              
int main() 
              
{ 
              
char *p; 
              
p=fun(); 
               
printf("%s\n",p);//hello world 
               
free(p); 
               
}


原因是堆区的内容一直存在,直到 free 才释放


总结:返回的地址,地址指向的内存的内容得存在,返回的地址才有意义。


13.指针保存函数的地址(函数指针)

1、函数指针的概念:


咱们定义的函数,在运行程序的时候,会将函数的指令加载到内存


的代码段。所以函数也有起始地址。


c 语言规定:函数的名字就是函数的首地址,即函数的入口地址


咱们就可以定义一个指针变量,来存放函数的地址。


这个指针变量就是函数指针变量。


2、函数指针的用处:


函数指针用来保存函数的入口地址。


在项目开发中,我们经常需要编写或者调用带函数指针参数的函数。


比如 Linux 系统中创建多线程的函数,它有个参数就是函数指针,接收线程函数的入口地址,即创建线程


成功后,新的任务执行线程函数。


int pthread_create(pthread_t *thread, const pthread_attr_t *attr, 
                
void *(*start_routine) (void *)                , void *arg); 
                                                                                
void *thread_fun1(void *arg) 
                 
{
                 
}
                 
void * thread_fun2(void *arg) 
                 
{
                 
}
                 
int main() 
                 
{
                 
pthread_t tid1,tid2; 
                 
pthread_create(&tid1,NULL,thread_fun1,NULL); 
                 
pthread_create(&tid2,NULL,thread_fun2,NULL);
                 
。。。。 
                  
}


3、函数指针变量的定义


返回值类型 (* 函数指针变量名 )( 形参列表 );


int(*p)(int,int);// 定义了一个函数指针变量 p,p 指向的函数


必须有一个整型的返回值,有两个整型参数。


int max(int x,int y) 
                   
{
                   
}
                   
int min(int x,int y) 
                   
{
                   
}


可以用这个 p 存放这类函数的地址。


p=max;


p=min;


4、调用函数的方法


1. 通过函数的名字去调函数(最常用的)


int max(int x,int y) 
                   
{
                   
}
                   
int main() 
                   
{ 
                   
int num; 
                   
num=max(3,5); 
                   
}


2. 可以通过函数指针变量去调用


int max(int x,int y) 
                   
{
                   
}
                   
int main() 
                   
{                     
int num; 
                    
int (*p)(int ,int); 
                    
p=max; 
                    
num=(*p)(3,5); 
                    
}


5、函数指针数组


概念:由若干个相同类型的函数指针变量构成的集合,在内存中连续的顺序存储。


函数指针数组是个数组,它的每个元素都是一个函数指针变量。


函数指针数组的定义:


类型名 (* 数组名 [ 元素个数 ]) (形参列表)


int(*p[5])(int,int);


定义了一个函数指针数组,数组名是 p ,有 5 个元素 p[0] ~p[4] ,每个元素都是函数指针变量,


每个函数指针变量指向的函数,必须有整型的返回值,两个整型参数。


例:


#include<stdio.h> 
                      
int max(int x, int y) 
                      
{ 
                      
int temp; 
                      
if (x > y) 
                      
temp = x; 
                      
else
                      
temp = y; 
                      
return temp; 
                      
}
                      
int min(int x, int y) 
                      
{ 
                      
int temp; 
                      
if (x < y) 
                      
temp = x; 
                      
else
                      
temp = y; 
                      
return temp; 
                      
}
                      
int add(int x, int y) 
                      
{ 
                      
return x + y; 
                      
}
                      
int sub(int x, int y) 
                      
{ 
                       
return x - y; 
                       
}
                       
int mux(int x, int y) 
                       
{ 
                       
return x * y; 
                       
}
                       
int main() 
                       
{ 
                       
int(*p[5])(int, int) = {mux,min,add,sub,mux}; 
                       
int num; 
                       
num = (*p[2])(10,20); 
                       
printf("num=%d\n", num); 
                       
return 0; 
                       
}


6、函数指针应用举例


给函数传参


#include<stdio.h> 
                         
int add(int x,int y) 
                         
{ 
                         
return x+y; 
                         
}
                         
int sub(int x,int y) 
                         
{ 
                         
return x-y; 
                         
}
                         
int mux(int x,int y) 
                         
{ 
                         
return x*y; 
                         
}
                         
int dive(int x,int y) 
                         
{ 
                         
return x/y; 
                         
}
                         
int process(int (*p)(int ,int),int a,int b) 
                         
{ 
                         
int ret; 
                         
ret = (*p)(a,b); 
                          
return ret; 
                          
}
                          
int main() 
                          
{ 
                          
int num; 
                          
num = process(add,2,3); 
                          
printf("num =%d\n",num); 
                          
num = process(sub,2,3); 
                          
printf("num =%d\n",num); 
                          
num = process(mux,2,3); 
                          
printf("num =%d\n",num); 
                          
num = process(dive,2,3); 
                          
printf("num =%d\n",num); 
                          
return 0; 
                          
}


14.经常容易混淆的指针概念


第一组:


1 、 int *a[10];


这是个指针数组,数组 a 中有 10 个整型的指针变量


a[0]~a[9] ,每个元素都是 int * 类型的指针变量


2 、 int (*a)[10];


数组指针变量,它是个指针变量。它占 4 个字节,存地址编号。


它指向一个数组,它加 1 的话,指向下个数组。


3 、 int **p;


这个是个指针的指针,保存指针变量的地址。


它经常用在保存指针的地址:


常见用法 1 :


int **p


int *q;


p=&q;


常见用法 2 :


int **p;


int *q[10];


分析: q 是指针数组的名字,是指针数组的首地址,是 q[0] 的地址。


q[0] 是个 int * 类型的指针。 所以 q[0] 指针变量的地址,是 int ** 类型的


p=&q[0]; 等价于 p=q;


例 34:


void fun(char**p) 
                            
{ 
                            
int i; 
                            
for(i=0;i<3;i++) 
                            
{ 
                            
printf("%s\n",p[i]);//*(
                            
p+i) 
                            
} 
                            
}
                            
int main() 
                            
{ 
                            
char *q[3]={"hello","world","China"}; 
                            
fun(q); 
                            
return 0; 
                            
}


第二组:


1 、 int *f(void);


注意: *f 没有用括号括起来


它是个函数的声明,声明的这个函数返回值为 int * 类型的。


2 、 int (*f)(void);


注意 *f 用括号括起来了, * 修饰 f 说明, f 是个指针变量。


f 是个函数指针变量,存放函数的地址,它指向的函数,


必须有一个 int 型的返回值,没有参数。


15.特殊指针

1、空类型的指针(void *)


char * 类型的指针变量,只能保存 char 型的数据的地址


int * 类型的指针变量,只能保存 int 型的数据的地址


float* 类型的指针变量,只能保存 float 型的数据的地址


void * 难道是指向 void 型的数据吗?


不是,因为没有 void 类型的变量


void* 通用指针,任何类型的地址都可以给 void* 类型的指针变量赋值。


int *p;


void *q;


q=p 是可以的,不用强制类型转换


举例:


有个函数叫 memset


void * memset(void *s,int c,size_t n);


这个函数的功能是将 s 指向的内存前 n 个字节,全部赋值为 c 。


memset 可以设置字符数组、整型数组、浮点型数组的内容,所以第一个参数,就必须是个通用指针


它的返回值是 s 指向的内存的首地址,可能是不同类型的地址。所以返回值也得是通用指针


注意: void* 类型的指针变量,也是个指针变量,在 32 为系统下,占 4 个字节


2、NULL


空指针 :


char *p=NULL;


咱们可以认为 p 哪里都不指向,也可以认为 p 指向内存编号为 0 的存储单位。


在 p 的四个字节中,存放的是 0x00 00 00 00


一般 NULL 用在给指针变量初始化。


main 函数传参:


例 35:


#include <stdio.h> 
                                
int main(int argc, char *argv[]) 
                                
{ 
                                
int i; 
                                
printf("argc=%d\n",argc); 
                                
for(i=0;i<argc;i++) 
                                
{ 
                                
printf("argv[%d]=%s\n",i,argv[i]); 
                                
}
                                
return 0; 
                                
}


注:资料来自2022最新千锋教育C语言。

举报

相关推荐

详解指针进阶-初学者也能看懂

0 条评论