C语言指针

1 指针的相关概念

操作系统给每个存储单元分配了一个编号, 从 0x00 00 00 00 ~0xff ff ff ff,这个编号咱们称之为地址

指针就是地址

指针变量

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

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

注意:
1:无论什么类型的地址, 都是存储单元的编号, 在 32 位平台下都是 4 个字, 即任何类型的指针变量都是 4 个字节大小
2: 对应类型的指针变量, 只能存放对应类型的变量的地址
举例: 整型的指针变量, 只能存放整型变量的地址

扩展:

字符变量 char ch; ch 占 1 个字节, 它有一个地址编号, 这个地址编号就是 ch 的地址

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

Int a=0x00 00 23 4f


2 指针的定义方法

2.1 简单的指针

数据类型 * 指针变量名;

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

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

2.2 关于指针的运算符

& 取地址 、 *取值

例 1:

int a=0x0000234f;
int *p;//在定义指针变量的时候*代表修饰的意思, 修饰 p 是个指针变量。
p=&a;//把 a 的地址给 p 赋值 , &是取地址符,
     //变量 p 里存放的就是 0x00002000
     //p 保存了 a 的地址, 也可以说 p 指向了 a
int num;
num=*p;//注意: 在调用的时候 *代表取值得意思 , *p 就相当于 p 指向的变量, 即 a
       //所以说 num 的值为 0x234f;

扩展:

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

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("a=%d\n",a);
    printf("*p_1=%d\n",*p_1);
    printf("b=%d\n",b);
    printf("*p_2=%d\n",*p_2);
    return 0;
} 

运行结果:

ljx@ljx-virtual-machine:~/桌面/C语言/指针$ ./a.out 
a=100
*p_1=100
b=200
*p_2=200
注意:
在定义 p_1 的时候, 因为是个局部变量, 局部变量没有赋初值, 它的值是随机的, p_1 指向哪里不一定, 所以 p_1就是个 野指针

2.3 指针大小

例 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;
} 

Ubunto 64位系统的运行结果:

ljx@ljx-virtual-machine:~/桌面/C语言/指针$ ./a.out 
char的地址长度=8
short int的地址长度=8
int的地址长度=8
long int的地址长度=8
float的地址长度=8
double的地址长度=8

例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;
} 

运行结果:

ljx@ljx-virtual-machine:~/桌面/C语言$ ./a.out 
&a = 0x7ffff6799b0c
p = 0x7ffff6799b0c

3 指针的分类

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

3.1.1字符指针

字符型数据的地址

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

3.1.2短整型指针

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

3.1.3整型指针

int *p;//定义了一个整型的指针变量 p, 只能存放整型变量的地址
int a;
p = &a;
注: 多字节变量, 占多个存储单元, 每个存储单元都有地址编号,
c 语言规定, 存储单元编号最小的那个编号, 是多字节变量的地址编号。

3.1.4长整型指针

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

3.1.5 float 型的指针

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

3.1.6 double 型的指针

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

3.1.7函数指针

3.1.8结构体指针

3.1.9指针的指针

3.1.10数组指针

总结:无论什么类型的指针变量, 在 32 位系统下, 都是 4 个字节, 只能存放对应类型的变量的地址编号。

4 指针和变量的关系

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

4.1.1直接通过变量的名称

int a;
a=100;

4.1.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("%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=0x1234,b=0x5678;
    char *p1,*p2;
    printf("%#x %0#x\n",a,b);
    p1=(char *)&a;
    p2=(char *)&b;
    printf("%0#x %0#x\n",*p1,*p2);
    p1++;
    p2++;
    printf("%0#x %0#x\n",*p1,*p2);
return 0;
}

结果为:

ljx@ljx-virtual-machine:~/桌面/C语言/指针$ ./a.out 
0x1234 0x5678
0x34 0x78
0x12 0x56
注意:
1: *+指针 取值, 取几个字节, 由指针类型决定,指针为字符指针则取一个字节,
指针为整型指针则取 4 个字节, 指针为 double 型指针则取 8 个字节。
2: 指针++ 指向下个对应类型的数据
字符指针++ , 指向下个字符数据, 指针存放的地址编号加 1
整型指针++,指向下个整型数据, 指针存放的地址编号加 4

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

5.1定义

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

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

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

例 7:

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

5.2 数组元素的引用方法

方法 1:

数组名[下标]

int a[10];
a[2]=100;

方法 2

指针名加下标

int a[10];
int *p;
p=a;
p[2]=100;//因为 p 和 a 等价

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

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

方法 3

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

int a[10];
int *p;
p=a;
*(p+2)=100;//也是可以的, 相当于 a[2]=100
解释: p 是第 0 个元素的地址, p+2 是 a[2]这个元素的地址。对第二个元素的地址取值, 即 a[2]

例 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;
} 

运行结果;

a[2]=2
p[2]=2
*(p+2)2
*(a+2)2
p=0x7ffc282c1da0
p+2=0x7ffc282c1da8

5.3 指针的运算

5.3.1加一个整数

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

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

例 9:

int a[10];
int *p;
p=a;
p+2;//p 是 a[0]的地址, p+2 是&a[2]
    //假如 p 保存的地址编号是 2000 的话, p+2 代表的地址编号是 2008

5.3.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

5.3.3 减法

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

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

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

例 12:

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

运行结果:

 3

5.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[10];
p=a; p=&a[0];这两种赋值方法是等价的

6 指针数组

6.1指针和数组的关系

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

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

指针数组的概念:

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

6.2指针数组的定义方法:

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

int * p[10];//定义了一个整型的指针数组 p, 有 10 个元素 p[0]~p[9],每个元素都是 int *类型的变量
int a;
p[1]=&a;
int b[10];
p[2]=&b[3];
//p[2]、 *(p+2)是等价的, 都是指针数组中的第 2 个元素。

6.3指针数组的分类

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

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

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

例 13:

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

运行结果:

Follw me
BASIC
Greatwall
FORTRAN
Computer

7指针的指针

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

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

int a;
int *p;
p=&a;
//*p === a
int **q;
q=&p;
//*q === p
//**q === *p === a
int ***m;
m=&q;
//*(*(*m)) === a
//p q m 都是指针变量, 都占 4 个字节, 都存放地址编号, 只不过类型不一样而已

8字符串和指针

8.1字符串的概念

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

8.2字符串的存储形式

数组、 字符串指针、 堆

8.2.1字符数组:

内存(栈、 静态全局区) 中开辟了一段空间存放字符串

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

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

8.2.2字符串指针

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

char *str = “I love C!”

定义了一个指针变量 str,只能存放字符地址编号,所以说 I love C! 这个字符串中的字符不能存放在 str 指针变量中。

str 只是存放了字符 I 的地址编号, “I love C! ” 存放在文字常量区

8.2.3堆

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

char *str =(char*)malloc(10*sizeof(char));
//动态申请了 10 个字节的存储空间,首地址给 str 赋值。
strcpy(str,"I love C"); 
//将字符串“I love C!” 拷贝到 str 指向的内存里

注意:

可修改性:
1. 栈和全局区内存中的内容是可修改的
char str[100]=”I love C!”;
str[0]=‘y’ ;//正确可以修改的
2. 文字常量区里的内容是不可修改的
char *str=”I love C!”;
*str =’y’;//错误, I 存放在文字常量区, 不可修改
3. 堆区的内容是可以修改的
char *str =(char*)malloc(10*sizeof(char));
strcpy(str,"I love C");
*str=’y’;//正确, 可以, 因为堆区内容是可修改的
注意: str 指针指向的内存能不能被修改, 要看 str 指向哪里。
str 指向文字常量区的时候, 内存里的内容不可修改
str 指向栈、 堆、 静态全局区的时候, 内存的内容是可以修改

8.3初始化

字符数组、 指针指向的字符串: 定义时直接初始化

char buf_aver[]="hello world";
char *buf_point="hello world";

堆中存放的字符串:不能初始化、 只能使用 strcpy、 scanf 赋值

char *buf_heap;
buf_heap=(char *)malloc(15);
strcpy(buf_heap,"hello world");
scanf(“%s”,buf_heap);

使用时赋值

字符数组: 使用 scanf 或者 strcpy

buf_aver="hello kitty"; 错误,因为字符数组的名字是个常量

strcpy(buf_aver,"hello kitty"); 正确

scanf("%s",buf_aver);  正确

指向字符串的指针:
buf_point="hello kitty";正确, 指向另一个字符串
strcpy(buf_point,"hello kitty"); 错误, 只读,能不能复制字符串到 buf_piont 指向的内存里
                                  取决于 buf_point 指向哪里。

9数组指针

9.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;
}

运行结果:

a=0x7fffc0c3e3c0
a+1=0x7fffc0c3e3d4

9.2数组指针的概念:

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

9.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;
} 

运行结果:

a=0x7ffeb66be7d0
a+1=0x7ffeb66be7e4
p=0x7ffeb66be7d0
p+1=0x7ffeb66be7e4

例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");
    }
}

运行结果:

1776 101 1981007577 32767 1981386752 
32767 16777216 257 2 0 
260832255 0 1981007593 32767 100 

9.4各种数组指针的定义:

9.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;

都是可以的~~~~

9.4.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;
}

运行结果:

a=0x7ffd545b1c10
a+1=0x7ffd545b1c60
p=0x7ffd545b1c10
p+1=0x7ffd545b1c60

9.5 三维数组指针

加 1 后指向下个三维数组 int(*p)[4][5][6];

p+1 跳一个三维数组;

什么样的三维数组啊?

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

配合:int a[7][4][5][6];

9.6 注意

容易混淆的内容:

指针数组

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

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;

9.7数组名字取地址

数组名字取地址 变成 数组指针

一维数组名字取地址, 变成一维数组指针, 即加 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=0x7ffe6591b5b0
a+1=0x7ffe6591b5b4
&a=0x7ffe6591b5b0
&a +1=0x7ffe6591b5d8

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.8数组名字和指针变量的区别

int a[10];
int *p;
p=a;

相同点:

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

引用数组元素的时候, a 和 p 等价

不同点:

1、 a 是常量、 p 是变量可以用等号’=’给 p 赋值, 但是不能用等号给 a 赋值

2、 对 a 取地址, 和对 p 取地址结果不同,因为 a 是数组的名字, 所以对 a 取地址结果为数组指针。

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

例 20:

#include <stdio.h>
int main(int argc, char *argv[])
{
    int a[10];
    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;
} 

运行结果:

a=     0x7ffd6e40d990
&a=    0x7ffd6e40d990
&a +1 =0x7ffd6e40d9b8
p=    0x7ffd6e40d990
&p=   0x7ffd6e40d988
&p +1=0x7ffd6e40d990

9.9 多维数组中指针的转换

在二维数组中, 行地址 取 * 不是取值得意思, 而是指针降级的意思, 由行地址(数组指针) 变成这一行第 0个元素的地址。 取*前后还是指向同一个地方, 但是指针的类型不一样了

例 21:

#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);
    printf("*a =%p\n",*a);// *a 变成了第 0 行第 0 列元素的地址
    printf("(*a)+1 =%p\n",(*a)+1 ); //结果为第 0 行第 1 列元素的地址
    return 0;
} 

运行结果:

a=0x7ffc8de8fb60
a +1=0x7ffc8de8fb74
*a =0x7ffc8de8fb60
(*a)+1 =0x7ffc8de8fb64

10指针和函数的关系

10.1指针作为函数的参数

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

例:

int num;
scanf("%d",&num);

10.1.1函数传参

(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
} 

运行结果:

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
} 

运行结果:

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
} 

运行结果:

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) 传数组

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

例 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;
} 

运行结果:

3
4

例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
}
hello
world
kitty}

例 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;
}
hello
world
kitty

10.2指针作为函数的返回值

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

例 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 才释放。

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

10.3指针保存函数的地址

咱们定义的函数, 在运行程序的时候, 会将函数的指令加载到内存的代码段。 所以函数也有起始地址。

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

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

10.3.1 函数指针变量的定义方法

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

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

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

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

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

p=max;
p=min;

10.3.2调用函数的方法

  • 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);
}

10.3.3函数指针数组

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

定义了一个函数指针数组, 有 10 个元素 p[0] ~p[9], 每个元素都是函数指针变量,指向的函数, 必须有整型的返回值, 两个整型参数。

10.3.4函数指针最常用的地方

  • 给函数传参

#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;
)

11经常容易混淆的指针

第一组:

1、 int *a[10];

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

a[0]~a[9]

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 型的返回值, 没有参数。

12特殊指针

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;
}

13. 回调函数

函数指针作为某个函数的参数

函数指针变量可以作为某个函数的参数来使用的,回调函数就是一个通过函数指针调用的函数。

简单讲:回调函数是由别人的函数执行时调用你实现的函数。

以下是来自知乎作者常溪玲的解说:
你到一个商店买东西,刚好你要的东西没有货,于是你在店员那里留下了你的电话,过了几天店里有货了,店员就打了你的电话,然后你接到电话后就到店里去取了货。在这个例子里,你的电话号码就叫回调函数,你把电话留给店员就叫登记回调函数,店里后来有货了叫做触发了回调关联的事件,店员给你打电话叫做调用回调函数,你到店里去取货叫做响应回调事件。

实例

实例中 populate_array() 函数定义了三个参数,其中第三个参数是函数的指针,通过该函数来设置数组的值。

实例中我们定义了回调函数 getNextRandomValue(),它返回一个随机值,它作为一个函数指针传递给 populate_array() 函数。

populate_array() 将调用 10 次回调函数,并将回调函数的返回值赋值给数组。

实例

#include <stdlib.h>  
#include <stdio.h> 
void populate_array(int *array, size_t arraySize, int (*getNextValue)(void))
{
    for (size_t i=0; i<arraySize; i++)
        array[i] = getNextValue();
} 
// 获取随机值
int getNextRandomValue(void){
    return rand();
} 
int main(void)
{
    int myarray[10];
    /* getNextRandomValue 不能加括号,否则无法编译,因为加上括号之后相当于传入此参数时传入了 int , 而不是函数指针*/
    populate_array(myarray, 10, getNextRandomValue);
    for(int i = 0; i < 10; i++) 
    {    
        printf("%d ", myarray[i]);
    }
    printf("\n");
    return 0;
}

编译执行,输出结果如下:

1804289383 846930886 1681692777 1714636915 1957747793
424238335 719885386 1649760492 596516649 1189641421 
  • 0
    点赞
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值