Day 09

文章目次

  

• 
  
  
  
  • 指针数组
    
  • 指针和函数
    
  • 技能名词表明
    
  • 技能细节
    
  • 课堂笔记
    
  
  

  
指针数组

1. #include<stdio.h>
2. int main()
3. {
4.          int a[3] = {0,1,2};
5.          //指针数组，它是数组，每个元素都是指针
6.          int *p[3];
7.          p[0] = &a[0];
8.          p[0] = a;
10.          p[1] = &a[1];
11.          p[1] = a+1;
13.          p[2] = &a[2];
14.          p[2] = a+2;
16.          //sizeof(p):3个元素，int*(32位)
17.          //3 * 4 = 12
18.          //sizoef(p[0]):第0给元素，int * = 4
19.          int n = sizeof(p)/sizeof(p[0]);
20.          int i =0;
21.          for(i = 0;i < n;i++)
22.         {
23.                 p[i] = &a[i]; //a+i
24.         }
25.          for(i = 0;i < n;i++)
26.         {
27.                 //printf("%d\n",*p[i])
28.                 printf("%d\n", *(*(p+i)));
29.                 //p[i]等价于*(p+i)
30.         }
31.         return 0;
32. }

复制代码

指针和函数

通过函数交换两个变量

1. #include<stdio.h>
2. void swap(int m, int n)
3. {
4.         int tmp;
5.         tmp = m;
6.         m = n;
7.         n = tmp;
8.         printf("m = %d,n = %d\n",m,n);
9. }
10. int main()
11. {      
12.         int a = 11;
13.         int b = 22;
15.         swap(a,b);//值传递
16.         printf("a = %d,b = %d\n",a,b);
17.         return 0;
18. }     

复制代码

地址通报

1. #include<stdio.h>
2. void swap(int *m, int *n)
3. {
4.         int tmp;
5.         tmp = *m;
6.         *m = *n;
7.         *n = tmp;
8. }
9. int main()
10. {
11.         int a = 11;
12.         int b = 22;
14.         //值传递，不管这个变量什么类型，只要是变量本身传递，就是值传递
15.         //swap(a,b);//值传递
16.         swap(&a,&b);  //地址传递，变量的地址
17.         printf("a = %d,b = %d\n",a,b);
18.         return 0;
19. }

复制代码

 形参中的数组01

1. #include<stdio.h>
2. int main()
3. {
4.         int a[] = {1,-2,3,-4,5,-6,7,-8,9};
5.         int i = 0;
6.         int n = sizeof(a)/sizeof(*a);
7.         printf("排序前\n");
8.         for(i = 0;i < n;i++)
9.         {
10.                 printf("%d ", a[i]);
11.         }
12.         printf("\n");
14.         //冒泡排序
15.         int j = 0;
16.         int tmp;
17.         for(i = 0;i < n-1;i++)
18.         {
19.                 for(j = 0;j < n-i-1;j++)
20.                 {      
21.                         if(a[j] > a[j+1])  //升序
22.                         {
23.                                 tmp = a[j];
24.                                 a[j] = a[j+1];
25.                                 a[j+1] = tmp;
26.                         }
27.                 }
28.         }
29.         printf("排序后\n");
30.         for(i = 0;i < n;i++)
31.         {
32.                 printf("%d ", a[i]);
33.         }
34.         printf("\n");
35.    

复制代码

形参中的数组02

1. #include<stdio.h>
2. //1、形参中的数组，不是数组，它是普通指针变量
3. //2、形参数组:int a[100000]，int a[]，int *a对编译器而已，没有任何区别
4. //3、编译器都是当做int*处理
5. //4、形参中的数组和非形参数组区别:形参中的数组是指针变量，非形参数组就是数组
6. //void print array(int a[100000])
7. //void print array(int a[])
8. void print_array(int a[], int n)
9. {
10.         int i = 0;
11.         //64位系统，sizeof(a)，a是指针变量，结果为8
12.         //sizeof(a[0])第0个元素，是int类型，结果为4
13.         /*int n = sizeof(a)/sizeof(a[0]);
14.         printf("sizeof(a) = %d\n". sizeof(a));
15.         printf("sizeof(a[0] = %d\n),sizeof(a[0])");
16.         */
17.         for(i = 0;i < n;i++)
18.         {
19.                 printf("%d, ",a[i]); //等价于*(a + i)
20.         }
21.         printf("\n");
23.         //a = NULL;   //形参中的数组，不是数组，它是普通指针变量        
24. }
25. int main()
26. {
27.         int a[] = {1,-2,3,-4,5,-6,7,-8,9};
28.         //print_array(a);  //传递的是，数组的首元素地址，&a[0]
29.         //a = NULL;
31.         int n = sizeof(a)/sizeof(*a);
32.         print_array(a,n); //应该把数组元素个数传递过去
33.         return 0;
34. }

复制代码

 返回局部变量的地址

1. #include<stdio.h>
2. int *fun()
3. {
4.         int a;  //Linux64位，不允许返回局部变量的地址
6.         return &a;
7. }
8. int main()
9. {
10.         int *p = NULL;
11.         p = fun(); //接受函数返回的地址   
12.         //到上一步使用完fun()，fun（）内的a，自动释放，下面操作野指针
13.         *p = 100; //操作指针所指向的内存
14.         return 0;
15. }

复制代码

返回全局变量的地址

1. #include <stdio.h>
3. int a; // 明确注释全局变量的用途
5. int *fun() {
6.     return &a; // 函数名更明确
7. }
9. int main() {
10.     int *p = fun();
11.     *p = 100;
12.     printf("*p = %d, a = %d\n", *p, a); // 合并输出
14.      *(fun()) = 111;
15.     printf("a = %d\n", a);
17.     return 0;
18. }

复制代码

指针和字符串

字符串打印阐明

1. #include<stdio.h>
2. int main()
3. {
4.         char str[] = "hello mike";
6.         //1、%s,从首元素开始打印，直到结束符位置
7.         //2、%s,操作的是指针所指向的内容
8.         //printf("str = %s\n", str);
10.         //2、str是首元素地址，如果想打印str本身的值，%p，&x，&d，%o
11.         printf("str = %p\n",str);  //一个个打印出来，地址
13.         //3、str代表第0个元素,它是char
14.         //printf("str3 = %s\n", *str);
15.         printf("str3 = %c\n", *str);
16.         int i = 0;
17.         while(str[i] != '\0')  //while(*(str+i) != '\0'))
18.         {
19.                 printf("%c",str[i]);
20.                 i++;
21.         }
22.         printf("\n");
25.         return 0;
26. }

复制代码

字符指针

1. #include<stdio.h>
2. int main()
3. {
4.         char str[] = "hello";
6.         str[0] = '1';
7.         *(str + 1) = '2';
8.         //printf("str = %s\n", str);  //12llo
9.         printf("str = %s\n",&str[0] +1); //2llo
10.         printf("str = %s\n",str+1); //2llo
12.         //定义一个指针，指向首元素
13.         char *p = NULL;
14.         p  = &str[0];
15.         p  = str; //数组名就是首元素地址
17.         *p = 'a';
18.         p++;  //p = p +1
19.         *p = 'b';
20.         printf("str = %s\n", str); //abllo
21.         printf("str = %s\n", p);  // &str[0]+1 //bllo
22.         printf("str = %s\n",p-1);
24.         return 0;
25. }

复制代码

字符串拷贝问题

1. #include<stdio.h>
2. #include<string.h>
3. int main()
4. {
5.         char buf[100];
6.         char *p = buf;
7.         //1、p指向buf的首元素
8.         //2、strcpy()是给p所指向的内存拷贝内容，字符串拷贝了buf
9.         strcpy(p,"hello mike abc");
11.         printf("p = %s, buf = %s\n",p,buf);
12.         return 0;
13. }
14. int main01()
15. {
16.         char *p;
17.         //1、不是给p变量拷贝内容
18.         //给p所指向的内存拷贝内容
19.         //3、P是野指针，给野指针所指向的内存拷贝内容，结果导致段错误
20.         strcpy(p, "hello mike abc");
21.         return 0;
22. }

复制代码

 字符串拷贝函数

1. #include<stdio.h>
2. //void my_strcpy(char dst[].char src[])
3. void my_strcpy(char *dst, char *src)
4. {
5.         int i = 0;
6.         while(*(src+i)!='\0')
7.         {
8.                 *(dst+i) = *(src+i);
9.                 i++
10.         }
11.         //结束符
12.         *(dst + i) = 0;
13. int main()
14. {      
15.         char src[] = "hello mike";
16.         char dst[100];
17.         char *p = buf;
19.         my_strcpy(p,src);  //自定义拷贝函数
20.         printf("dst = %s\n",dst);
21.         return 0;
22. }

复制代码

const修饰的字符指针 

1. #include<stdio.h>
2. int main()
3. {
4.         char buf[] = "hello";
5.         char *p1 = buf;
6.         *p1 = 'a'; //改变指针所指向的内存
7.         p1 = NULL;//改变指针变量本身
8.                   
9.         //const修饰*,指针所指向的内存不能修改
10.         const char *p2 = buf;
11.         //*p2 = 'a'; //err
12.         p2 = NULL; //ok
13.         return 0;
14. }     

复制代码

 字符串常量

1. #include<stdio.h>
2. void fun()
3. {
4.         printf("fun s2 = %p\n","hello mike");
5. }
6. int  main()
7. {
8.         //1、每个字符串都是一个地址，这个地址是指字符串首元素地址
9.         //2、字符串常量放在data区，文字常量区
10.         
11.         printf("s1 = %s\n","hello mike");
12.         printf("s2 = %s\n","hello mike");
13.         printf("s3 = %s\n","hello mike"+1);
15.         //fun();
16.         return 0;
17. }

复制代码

 文字常量区不答应修改01

1. #include<stdio.h>
2. #include<string.h>
3. int main()
4. {
5.         //1、字符串常量就是字符串的首元素地址
6.         printf("s1 = %p\n","hello mike");
8.         char *p1 = "hello mike";
9.         printf("p1 = %p\n",p1);
11.         char *p2 = "hello mike";
12.         printf("p2 = %p\n",p2);
14.         //2、字符串常量，文字常量区的字符串，只读，不能修改
15.         printf("*p1 = %c\n",*p1); //读，ok
17.         //3、p1指向字符串常量，字符串常量为只读，不能修改
18.         //*p1 = 'a'; //修改 //err
20.         char *p3 = "hello";
22.         //4、p3指向文字常量区，不能改
23.         strcpy(p3,"abc"); //err
25.         return 0;
26. }

复制代码

  文字常量区不答应修改02

1. #include<stdio.h>
2. void fun(char *tmp)
3. {
4.         *tmp = 'a'; //err
5. }                  
6. int main()
7. {
8.         char *p = NULL; //p是变量
9.         "hello mike" //字符串常量，首元素地址
10.                      
11.         p = "hello mike"; //p指向字符串
12.         //*p = 'a'; //err,指向文字区常量，文字常量区内容只读
13.         p = NULL; //ok
14.         p = "hello"  //ok
15.                      
16.         char *p2 = "abc";
17.         fun(p2); //p2的值，是“abc”首元素地址
18.         return 0;
19. }

复制代码

字符串常量初始化问题

1. #include<stdio.h>
2. int main()
3. {      
4.         //1、p指针保存了“hello”的地址
5.         //2、指针所指向的内存不能修改
6.         char *p = "hello";
7.         
8.         //1、把"hello"一个一个字符放在buf数组中
9.         //2、数组的元素可以修改
10.         char buf[] = "hello";
11.         
12.         return 0;
13. }

复制代码

main形参利用阐明 

1. #include<stdio.h>
3. //argv[]:它是数组，数组每个元素都是char*，每个元素都是字符地址
4. //argc:argv[]元素个数
5. //main()函数参数，需要用户传递
6. int main(int argc,char *argv[])
7. {
8.         int i =0;
9.         for(i = 0;i < argc;i++)
10.         {
11.                 printf("test = %s\n",argv[i]);
12.         }
13.         return 0;
14. }

复制代码

 字符指针数组

1. #include<stdio.h>
2. //void fun(int a[])
3. //void fun(int a[100])
4. void fun()
5. {
6. }
8. //void print_array(char * p[100],int n)
9. void print_array(char *p[], int n)
10. //void print_arrauy(char **p, int n)
11. {
12.         int i = 0;
13.         for(i = 0;i < n;i++)
14.         {
15.                 printf("%s\n",p[i]);
16.         }
17. }
18. int main()
19. {
20.         char *p1 = "hello";
21.         char *p2 = "abc";
22.         char *p3 = "mike";
24.         char *p[] = {"hello", "abc", "mike"};
25.         int n = sizeof(p)/sizeof(*p);
26.         int i = 0;
27.         for(i = 0;i < n;i++)
28.         {
29.                 printf("%s\n", p[i]);
30.         }
31.         return 0;
32. }

复制代码

查找匹配字符串出现的次数

2. #include<stdio.h>
3. #include<string.h>
4. int main()
5. {
6.         char *p = "11abcd11122abcd333abcd3322abcd3333322qqq";
7.         int i = 0; //累加器
8.         char *tmp = NULL;
10.         while(1)
11.         {
12.                 //查找匹配字符串，如果找到，返回匹配字符串的地址，没有找到返回空
13.                 tmp = strstr(p, "abcd");
14.                 if(tmp == NULL)
15.                 {
16.                         break;  //跳出循环
17.                 }
18.                 else //找到
19.                 {
20.                         i++; //累加
21.                         //重新设置新的起点
22.                         p = tmp + strlen("abcd");
23.                 }
24.         }
26.         printf("出现abcd的次数为； %d\n", i);
27.         return 0;
28. }

复制代码

两头堵类型

1. #include<stdio.h>
2. #include<string.h>
3. int main()
4. {
5.         char *p = "  123456789   ";
6.         char *start = p; //首元素地址
7.         char *end = p + strlen(p) - 1; //尾元素地址
9.         //从左往右
10.         while(*start == ' ' && *start != '\0')
11.         {
12.                 start++;
13.         }
14.         while(*end == ' ' && end != p)
15.         {
16.                 end--;
17.         }
18.         int n = end-start+1;  //5-1=4,但是实际上元素由5个所以+1
19.         printf("n = %d\n", n);
21.         char buf[100]="aaaaaaaaaaa";
22.         strncpy(buf,start,n);
23.         buf[n] = 0; //结束符
24.         printf("buf = %s\n",buf);
25.         return 0;
26. }

复制代码

课堂笔记

1. void fun(int b[10][10]); //ok
2. void fun(int **p); //err,二维数组不是二级指针
3.                   
4. int *fun(); //返回值是指针类型，指针函数
5.             
6. 0          数字0，和'\0'等价
7. '\0'
8. '0'
10. '0'字符'0'，不是结束符，ascii为48
12. char a[] = {'a', 'b'};
13. printf("%s\n",a); //乱码，没有结束符
14.                   
15. char a[10] = {'a', 'b'}; //后面自动补0
16. printf("%s\n",a); //正常
17.                   
18. char a[] = {'a', 'b', 0};
19. char a[] = {'a', 'b','\0'};
20. printf("%s\n",a);//正常
21.                  
22. char a[] = {'a','b','0'};
23. printf("%s\n",a); //乱码，没有结束符
24.                   
25. char buf[] = "hello"; //以字符串初始化，自动隐藏结束符'\0'

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。

继续阅读请点击广告