C语言（七）

作业分析讲解

======================

 1.  清空数组常见的操作

           char  buf[20]={0}  //偷懒的写法，buf中所有的字符ASCII都是0

           char  buf[20];  //没有初始化，里面是随机数

           bzero(buf,20);   //把数组buf中20字节的数据全都置0

 2.  总结目前学会的关于数组的常见操作(基本功)

           操作一：  删除数组中的元素

           操作二：  数组逆序

           操作三：  数组排序

3. 计算机常识

           中文汉字：有不同的编码，有些编码一个汉字占2个字节，有些编码一个汉字占3个字节

                             常见的编码：   GB2312  国标  中国人自己弄的

                                                     BIG5       台湾

                                                     UTF-8  外国人给我们汉字编码     

4.  输入字符串的时候，scanf无法读取键盘输入的空格，scanf遇到空格或者回车，就认为字符串结束了

                     如果真的要输入空格：  请使用C语言另外两个函数

                                            fgets()或者gets()

                                                       char *gets(char *s);  //把键盘输入的字符串保存到指针s中

                                                  

C语言指针

===========================

  1.  一维数组和指针的关系

             第一种：  int类型指针和int类型数组之间的关系

             第二种：  char类型指针和char类型数组之间的关系

                         规则:  C语言规定，数组名出现在表达式中，代表该数组首元素的地址(数组名就是个指针，指向首元素的指针)

                                   C语言规定，数组名取地址出现在表达式中，代表指向整个数组的一个指针，称作数组指针

                总结: 一维数组和指针之间的关系有如下几种常见写法

                         写法一：  char buf[10]="hello";

                                         char *p=buf;

                                         *(p+i);   //i -->0到strlen(buf)

                         写法二： char buf[10]="hello";

                                         char *p=buf;

                                         p[i];   //i -->0到strlen(buf)

 

练习：

 

 

 

  2.  野指针

               目前为止，C语言保持多个相同类型的数据有如下几种方法：

                           方法一：数组

                           方法二：指针

               定义了指针，但是这个指针没有明确的指向，是不能使用的(很危险，容易产生段错误)

                #include <stdlib.h>

               void *malloc(size_t size);  //给指针分配size个字节的内存空间，不会自动把内存空间清零

                          char  *p=malloc(20);  //给指针p分配20字节的内存空间

                          int  *p=malloc(20); //给指针p分配20字节的内存空间

               void free(void *ptr);  //把之前操作系统分配给你内存空间释放(把内存还给操作系统)

                          free(p);

               void *calloc(size_t nmemb, size_t size); //分配内存空间同时会自动把内存空间清零

                         char  *p=calloc(5,10);  //申请分配5块内存空间，每一块的大小是10个字节，总共分配5*10=50字节的空间

                         int  *p=calloc(10,4);  //10块内存空间，每一块大小是4字节

               void *realloc(void *ptr, size_t size);  //重新分配内存空间，改变之前分配的内存空间的大小

                         realloc(p,100);  //重新给p申请100个字节的存储空间

                         注意：重新分配的内存首地址可能跟原来的地址一样，也可能不一样

  3.  指针的加法和减法运算

              指针的加法运算：(指针加上一个整数)

              两个指针直接相加 --》没有任何实际意义，面试题也不会这么写

                      char  buf[10];

                      char  *p=buf;  //指向首地址

                      p+1;  //  初学者有错误的认识，把地址当成是数字+1

                      总结：指针做加法运算，加的是类型的大小

              指针的减法运算：(指针减去一个整数)

              两个指针直接相减---》只能是在数组里面两个指针相减有意义

                         计算公式：  (p-q)结果是： (p-q)/指针类型的大小

                     总结：指针做减法运算，减的是类型的大小

  4.  空指针和void类型的指针

              空指针：  在C语言中用NULL表示,在系统中NULL就是0x0000 0000地址

                         用法一：判断函数的返回值(返回指针)，是否正确

                             void *malloc(size_t size);

                             char *p=malloc(10);  //p可以存放10个字符

                             if(p==NULL)  //说明malloc申请10个字节空间失败了

                             else        //说明申请成功

                             int *q=malloc(20);  //q可以存放5个整数

                        用法二：定义一个指针的时候，先让它指向NULL，后面改变指向

                            int *p=NULL;  //p是个野指针，p由系统随机指向

                            p=&a;

                            scanf("%d",p)

            void类型的指针： C语言表示通用类型指针

                           void类型的指针可以转换C语言其它类型的指针

                           void *malloc(size_t size);  //void *通用性比较强

                          char *p=malloc();

                          int *p=malloc();

                          double *p=malloc();

 

  5. 一维数组跟指针有关的几种写法

             int  a[5];

             a   //指针   int  *

             &a  //指针，指向整个数组的一个指针(称作数组指针)  int (*)[5]

             &a[0]  //指针  int *

             a[0]  //普通变量，不是指针

   6. 数组指针和指针数组

             数组指针：中心词是指针

                   定义：    int a[5]; ---》类型  int [5]

                                  int (*p)[5];

                                  p=&a;

                                  char   b[9];  --》 类型    char [9]

                                  char (*p)[9];

                                  p=&b;

              指针的一般定义：

         公式：     类型  *名字

                    int  *p;

                    char *p;

         数组指针也符合这个公式

                    int a[100];

                    int (*p)[100]=a;  //左右两边指针类型不一致

                      数组指针   int类型指针

                    int (*p)[100]=&a;  //左右两边指针类型一致

                      数组指针   数组指针

    

           指针数组：中心词是数组

                     指针数组：本质上还是数组，只不过这个数组里面存放的全部都是相同类型的指针

                                       前面学习的数组，里面存放的都是相同类型的普通变量

                     数组的一般定义：

                                公式：   类型   数组名[数组元素个数]  

                                              int      a[10];

                                              int *    b[10]; // 定义了一个最多可以存放10个int *的数组

                                              char  *c[10]; //定义了一个最多可以存放10个char*的数组

 

作业：

       第一题：

      char  *p;

      int  *p;

      double *p     sizeof(p)   sizeof(*p) //看看大小是多少，为什么？？

             32位的ubuntu系统  ---》全部都是4个字节

             64位的ubuntu系统  ---》全部都是8个字节

              原因:  在64位系统上所有的地址长度都是8字节，而指针里面存放的就是其他变量的首地址，所以指针大小全部都一样

     第二题：

           char  buf[10]=''gecchina";

           char *p=&buf[3];

            p=p+2;

            *p='#';

            printf("buf is:%s\n",buf);

     第三题：  

          char  buf[5][10]={"hello","world","china"};

          char *p=&buf[1][3];  //world中l的地址

          char *q=&buf[2][1];  //china中h的地址

           printf("q-p  is:%d\n",q-p);

                   总结： 指针相减表示它们之间间隔了多少个数据成员

   第四题：