一、指针变量的定义

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 }*/