一、指针变量的定义
1. 格式：变量类型 *指针变量名;
2. 举例：int *p; char *p2;
3. 注意：定义变量时的*仅仅是指针变量的象征
二、利用指针变量简单修改其他变量的值
1.指向某个变量
int a;
int *p;
p = &a;
或者
int *p = &a;
2.修改所指向变量的值
*p = 10;
3.在函数内部修改外面变量的值
int a = 10;
change(&a);
void change(int *n)
{
*n = 20;
}
三、指针与数组
1.将数组当做函数参数传入时，会自动转为指针
四、指针与字符串
1.定义字符串的2种方式
1> 利用数组
char name[] = "ios";
* 特点：字符串里面的字符是可以修改的
* 使用场合：字符串的内容需要经常修改
2> 利用指针
char *name = "ios";
* 特点：字符串其实是一个常量字符串，里面的字符是不能修改
* 使用场合：字符串的内容不需要修改，而且这个字符串经常使用
2.定义字符串数组
1> 利用二维字符数组
char names[2][10] = {"jack", "rose"};
2> 利用指针数组
char *names[2] = {"jack", "rose"};
五、代码
1.定义
1 #include <stdio.h>
2
3 void change(int);
4
5 int main()
6 {
7 /*
8 int a = 90;
9
10 change(&a);
11
12 printf("a=%d\n", a);
13 */
14
15 // 变量类型 变量名;
16 // 格式：变量类型 *变量名;
17 // 定义了一个指针变量p
18 // 指针变量只能存储地址
19 // 指针就一个作用：能够根据一个地址值，访问对应的存储空间
20 // 指针变量p前面的int：指针变量p只能指向int类型的数据
21 int *p;
22
23 int a = 90;
24
25 // 指针变量p指向了变量a
26 p = &a;
27
28 *p = 10;
29
30 a = 20;
31
32 printf("%d\n", *p);
33
34 //printf("%d\n", a);
35
36 return 0;
37 }
38
39 void change(int n)
40 {
41 n = 10;
42 }
2.使用注意
1 #include <stdio.h>
2
3 int main()
4 {
5 /* 不建议的写法， int *p只能指向int类型的数据
6 int *p;
7 double d = 10.0;
8 p = &d;*/
9
10 /* 指针变量只能存储地址
11 int *p;
12 p = 200;
13 */
14
15 /* 指针变量未经过初始化，不要拿来间接访问其他存储空间
16 int *p;
17 printf("%d\n", *p);
18 */
19
20 int a = 10;
21 /*
22 int a;
23 a = 10;
24 */
25
26 /*
27 int *p;
28 p = &a;
29 */
30 // 定义变量时的*仅仅是一个象征，没有其他特殊含义
31 int *p = &a;
32
33 // 不正确的写法
34 // *p = &a;
35 p = &a;
36
37 // 这个时候的*的作用：访问指向变量p指向的存储空间
38 *p = 20;
39
40
41 char c = ‘A‘;
42
43 char *cp = &c;
44
45 *cp = ‘D‘;
46
47 printf("%c\n", c);
48
49 return 0;
50 }
3.指向指针的指针
1 #include <stdio.h>
2 int main()
3 {
4 int a = 10;
5
6 int *p = &a;
7
8 int **pp = &p;
9
10 // a = 20;
11
12 // *p = 20;
13
14 /*
15 (*pp) == p
16
17 *(*pp) == *p = a
18
19 **pp == *p = a
20 */
21 **pp = 20;
22
23 printf("%d\n", a);
24
25 //int ***ppp = &pp;
26
27 /*
28 char a2 = ‘A‘;
29 char *p2 = &a2;
30 */
31
32 return 0;
33 }
4.练习
1 #include <stdio.h>
2 void swap(int *v1, int *v2);
3
4 int main()
5 {
6 /*
7 int a = 10;
8 int b = 11;
9
10 swap(&a, &b);
11 */
12
13
14 int a2 = 90;
15 int b2 = 89;
16
17 swap(&a2, &b2);
18
19 printf("a2=%d, b2=%d\n", a2, b2);
20 return 0;
21 }
22
23 /* 不能交换外面实参的值，仅仅是交换了内部指针的指向
24 void swap(int *v1, int *v2)
25 {
26 int *temp;
27 temp = v1;
28 v1 = v2;
29 v2 = temp;
30 }*/
31
32 // 完成两个整型变量值的互换
33 void swap(int *v1, int *v2)
34 {
35 int temp = *v1;
36 *v1 = *v2;
37 *v2 = temp;
38 }
39
40 /* 交换的只是内部v1、v2的值
41 void swap(int v1, int v2)
42 {
43 int temp = v1;
44 v1 = v2;
45 v2 = temp;
46 }*/
1 #include <stdio.h>
2 int sumAndMinus(int n1, int n2, int *n3);
3
4 int main()
5 {
6 int a = 10;
7 int b = 7;
8
9 // 存储和
10 int he;
11 // 存储差
12 int cha;
13 c
14 he = sumAndMinus(a, b, &cha);
15
16 printf("和是%d, 差是%d\n", he, cha);
17
18 return 0;
19 }
20
21 // 返回值是
22 int sumAndMinus(int n1, int n2, int *n3)
23 {
24 *n3 = n1 - n2;
25
26 return n1 + n2;
27 }
5.指针和数组
1 #include <stdio.h>
2
3 /*
4 1.数组元素的访问方式
5 int ages[5];
6 int *p;
7 p = ages;
8 1> 数组名[下标] ages[i]
9 2> 指针变量名[下标] p[i]
10 3> *(p + i)
11
12 2.指针变量+1，地址值究竟加多少，取决于指针的类型
13 int * 4
14 char * 1
15 double * 8
16 */
17 void change(int array[]);
18
19 int main()
20 {
21 // 20个字节
22 int ages[5] = {10, 11, 19, 78, 67};
23
24 change(ages);
25
26 return 0;
27 }
28
29 // 利用一个指针来接收一个数组，指针变量array指向了数组的首元素
30 void change(int *array)
31 {
32 printf("%d\n", array[2]);
33 //printf("%d\n", *(array+2));
34 }
35
36 /*
37 void change(int array[])
38 {
39 int s = sizeof(array);
40
41 printf("%d\n", s);
42 }*/
43
44 void test()
45 {
46 double d = 10.8;
47 double *dp;
48 dp = &d;
49
50 printf("dp = %p\n", dp);
51 printf("dp + 1 = %p\n", dp + 1);
52
53 int ages[5] = {10, 9, 8, 67, 56};
54
55 int *p;
56 // 指针变量p指向了数组的首元素
57 p = &ages[0];
58 // 数组名就是数组的地址，也是数组首元素的地址
59 //p = ages;
60
61 /*
62 p ---> &ages[0]
63 p + 1 ---> &ages[1]
64 p + 2 ---> &ages[2]
65 p + i ---> &ages[i]
66 */
67
68 //printf("%d\n", *(p+2));
69
70 printf("%d\n", p[2]);
71
72 /*
73 for (int i = 0; i<5; i++) {
74 printf("ages[%d] = %d\n", i, *(p+i));
75 }*/
76
77
78 // printf("%p\n", p);
79 // printf("%p\n", p + 1);
80 // printf("%p\n", p + 2);
81 }
6.指针和字符串
1 #include <stdio.h>
2
3 /*
4 1.常量区
5 存放一些常量字符串
6
7 2.堆
8 对象
9
10 3.栈
11 存放局部变量
12
13 掌握：
14 定义字符串的2种方式
15 1> 利用数组
16 char name[] = "itcast";
17 * 特点：字符串里面的字符是可以修改的
18 * 使用场合：字符串的内容需要经常修改
19
20 2> 利用指针
21 char *name = "itcast";
22 * 特点：字符串其实是一个常量字符串，里面的字符是不能修改
23 * 使用场合：字符串的内容不需要修改，而且这个字符串经常使用
24 */
25
26 int main()
27 {
28 char name[20];
29
30 printf("请输入姓名：\n");
31
32 scanf("%s", name);
33
34 // ‘j‘ ‘a‘ ‘c‘ ‘k‘ ‘\0‘
35
36 //printf("%c\n", name[3]);
37
38 //printf("刚才输入的字符串是：%s\n", name);
39
40 return 0;
41 }
42
43 // 定义字符串数组
44 void test2()
45 {
46 char *name = "jack";
47
48 //int ages[5];
49
50 // 指针数组（字符串数组）
51 char *names[5] = {"jack", "rose", "jake"};
52
53 // 二维字符数组（字符串数组）
54 char names2[2][10] = {"jack", "rose"};
55 }
56
57 // 定义字符串
58 void test()
59 {
60 // 字符串变量
61 char name[] = "it";
62 name[0] = ‘T‘;
63
64 //printf("%s\n", name);
65
66
67 // "it" == ‘i‘ + ‘t‘ + ‘\0‘
68 // 指针变量name2指向了字符串的首字符
69
70 // 字符串常量
71 char *name2 = "it";
72
73 char *name3 = "it";
74
75 //*name2 = ‘T‘;
76
77 //printf("%c\n", *name2);
78
79 printf("%p\n%p\n", name2, name3);
80
81 //printf("%s\n", name2);
82 }
1 #include <stdio.h>
2 /*
3 (不包括\0)
4 编写一个int string_len(char *s)，返回字符串s的字符长度
5
6 */
7 int string_len(char *s);
8
9 int main()
10 {
11 //char *name = "itcast";
12
13 // 男 \u434\u4343\u434
14
15 int size = string_len("tre777");
16
17 printf("%d\n", size);
18 return 0;
19 }
20
21 int string_len(char *s)
22 {
23 // 1.定义一个新的指针变量指向首字符
24 char *p = s;
25
26 /*
27 while ( *s != ‘\0‘ )
28 {
29 s++;
30 }*/
31
32 while ( *s++ ) ;
33
34 return s - p - 1;
35 }
36
37 /*
38 int string_len(char *s)
39 {
40 // 记录字符的个数
41 int count = 0;
42
43 // 如果指针当前指向的字符不是‘\0‘
44 // 首先*s取出指向的字符
45 // 然后s++
46 while ( *s++ )
47 {
48 // 个数+1
49 count++;
50
51 // 让指针指向下一个字符
52 //s = s + 1;
53 //s++;
54 }
55
56 return count;
57 }
58 */
59
60 /*
61 int string_len(char *s)
62 {
63 // 记录字符的个数
64 int count = 0;
65
66 // 如果指针当前指向的字符不是‘\0‘
67 while ( *s != ‘\0‘)
68 {
69 // 个数+1
70 count++;
71
72 // 让指针指向下一个字符
73 //s = s + 1;
74 s++;
75 }
76
77 return count;
78 }*/
时间： 2024-10-11 10:36:00