8th day

 P171 - 复习7th day内容

        return      返回

        break       跳出循环

        continue    跳过本次循环（到循环尾）

 P172 - 预处理指令的概述

    1.预处理指令/预处理代码。

      C语言的代码主要分为两类。

        1.C代码。

        2.预处理代码（以#开头的代码都叫做预处理代码）

    2.手写C语言的步骤。

               ----->   编译器在编译的时候做的事情           <-------

    .c源文件 -> 执行.c文件中的预处理代码 -> 检查语法 -> 编译成.o的目标文件 -> 链接生成可执行文件 -> 执行

    3.预处理指令

        3.1 预处理指令的分类

            a. 文件包含指令.  #include

            b. 宏定义        #define

            c. 条件编译指令   #if

        3.2 预处理指令的特点

            a.  都是以#开头。

            b.  预处理指令后面没有分号

            c.  在编译的时候，检查语法之前。

 P173-P175 - 文件包含指令的基本使用(#include) & 相对路径和绝对路径 & 双引号包含文件和尖括号包含文件

    1.文件包含指令：#include

        1.1.作用：可以将指定的文件的内容拷贝到写指令的地方。

        1.2 语法：

            #include "文件路径"

            #include <文件路径>

        1.3 使用

            #include "/Users/babylon/Desktop/1.txt"

            在编译之前将文件的内容COPY到这个地方，然后检查语法生成.o目标文件。

    2.一般情况下，被包含的文件放在源文件目录下。

方便文件管理。

        被包含文件与源文件在同一目录下的时候，就直接使用相对路径。

        绝对路径：路径从根目录开始。

        相对路径：相对于当前文件夹的路径。

    3.文件路径用双引号和括号的区别。

        1.都是将指定的文件的内容包含到写指令的地方。

        2.不通电在于寻找文件的方式不一样。

            a.如果是文件路径用双引号引起来。

                #include "1.txt"

                ->先去当前源文件所在的目录中查找这个文件，如果有直接包含，

                ->如果没有，就去系统自带的编译器目录中查找。

如果有就直接包含，没有就报错。

            编译器目录:"/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.11.sdk/usr/include"

            b.如果文件路径我们使用尖括号引起来。

                #include <1.txt>

                ->直接去系统自带的编译器目录中查找。

如果有包含，有过没有就报错。

    4.使用建议：

        4.1 我们自定义的被包含文件，不要乱放，放在和源文件一个目录下.

        4.2 如果包含的文件是我们自定义的文件，那么使用""引用.

        4.3 如果使用系统自带的，就用使用<>引用.

 P176 - 系统编译器目录

    系统自带的编译器目录：

        C语言标准函数库。

->系统自带函数。

        stdio.h     输入输出相关函数声明

        stdlib.h    一些核心函数声明

        要调用C语言函数库里的函数，先将这个函数声明所在的头文件包含进来，才可以调用这个函数。

 P177 - 多文件开发

    分模块开发。

    写模块的人要提供两个文件。

    .h文件 head 头文件。

这个文件中写函数的声明。

    .c文件 写函数实现。

    调用的人引用.h文件就可以了。

    当程序内函数过多的时候就要考虑分模块开发。

 P178 - C语言里的4种进制。

    进制：一种计数方式。

侧重点在于计数的时候是逢多少进一。

    C语言可以识别二进制，八进制，十进制，十六进制。

    1.二进制

        逢二进一。

每位数字使用0或1来表示。

        在C语言中，要写一个2进制数，就在前面加0b的前缀。

            例： int num = 0b00010001;// 二进制00010001 = 十进制 17

    2.八进制

    

        逢八进一。

每位数字只能是0 1 2 3 4 5 6 7；

        在C语言中，要写一个8进制数，就在前面写一个0的前缀。

        在8进制的数前面加1个0，代表这个数是1个八进制数。

        例： int num1 = 01234  ;// 八进制 01234 = 十进制 668

        %o 将整型变量中的数据以八进制的形式输出出来。

    3.十进制

        逢十进一。

每位数字只能是0 1 2 3 4 5 6 7 8 9；

        在C语言中直接写1个整数，那么默认就是十进制的。

        %d 将整型变量中的数据以十进制的形式输出出来。

    4.十六进制

        逢十六进一。

每位数字只能是0 1 2 3 4 5 6 7 8 9 A B C D E F

        在C语言中，要写一个十六进制数，就在前面写一个0x的前缀。

        int num2 = 0x1234567A ;//0x1234567A = 305419898

             int num  = 0b00010001 ;    //17

             int num1 = 01234  ;        //668

             int num2 = 0x1234567A ;    //305419898

             printf("%d + %d + %d = %d\n",num,num1,num2,getsum(num, num1, num2));

             17 + 668 + 305419898 = 305420583

    5 占位符：

        %o 八进制  %d  十进制  %x 十六进制

 P180-184 - 最重要的4个概念&进制相互转换。

    1.基本概念

        

            94357210

              ↓

              543210

        数码是3，数位是5，位权是300000 (3*10的5次方）

        数码：数据的每一位的数字。

        数位：数码在这个数当中的位置（从右到左数，从0开始）

        基数：就每一个数码可以有多少个数据来表示。

（指的就是这个数的进制）

        位权：数码*（基数的数位次方） 任何数的0次方都为1.

    2.十进制转二进制。

    

        除2取余法：将这个数除以2，直到商为0或者1，然后将商和所有余数倒序，就是这个十进制对应的二进制。

    3.二进制转换为十进制。

        加权法：将这个二进制数的每个数码的位权相加，就是这个二进制数对应的十进制数。

    

        二进制的位权：加入每1个数码都是有1，

    4.十进制转八进制。

        除8取余法：将这个数除以8，直到商小于8为止，然后将商和所有余数倒序，就是这个十进制对应的八进制。

    5.八进制转十进制。

        

        加权法：将这个八进制数的每个数码的位权相加，就是这个八进制数对应的十进制数。

    6.二进制转换为八进制。

        三合一法则：将这个二进制从低位到高位，每3位分成一组，高位不够补0.

                  将每一组转换成十进制。

将每一组的十进制连起来，就是这个二进制对应的八进制。

        

            例如 ：001 011 100 110 011

                   1   3   4   6   3

    7.八进制转为二进制。

        一拆三法则：将这个八进制数的每一个数码，拆为1个三位的二进制数，把这个二进制数连起来。

            例如： 1   3   4   6   7   4

                 001 011 100 110 111 100

    8.二进制转为十六进制

        

        四合一法则：将这个二进制从低位到高位，每4位分成一组，高位不够就补0.

                  将每一组转换成对应的十六进制，将每一组转换成功的十六进制数链接起来。

    9.十六进制转二进制

        一拆四法则：将这个十六进制数的每一个数码，拆为1个四位的二进制数，把这个二进制数连起来。

 P185 内存的构造和变量占用的字节数

    数据内存中的数据存储单元由一个一个的二进制位组成。

每一个二进制位只能存储1或者1。

    将内存中的八个二进制位分为一组，叫做一个字节。

作为存储数据最小基本单位。

。

    8bit = 1byte

    1024 byte = 1 KB

    1024 KB   = 1 MB

    1024 MB   = 1 GB

    1024 GB   = 1 TB

    声明变量 = 向系统在内存中申请指定字节数的连续的字节空间。

    int     ： 4个字节

    double  ： 8个字节

    folat   :  4个字节

    char    :  1个字节

 P186 sizeof运算符。

    计算变量、常量在当前系统上内存中占用的字节数。

    1.使用方法

        a.sizeof(数据类型) 就会返回这个数据类型的变量在内存中占据多少字节。

        b.sizeof(变量名)   就会返回这个变量在内存中占据多少个字节。

        c.sizeof(常量)     就会返回这个常量数据在内存中占据多少个字节。

        注意：

        char 类型的变量在内存中占据1个字节。

        char 类型的常量在内存中占据4个字节。

    2.使用简写方法：

        在使用sizeof的时候，当判断的东西不是数据类型的时候可以省略小括号。

    3.变量在内存中占据的字节数会因为系统版本编译器的不同而发生变化。

P187 原码、反码、补码

    1.  无论任何数据在内存中存储的时候都是以二进制的形式存储的。

        原码、反码、补码都是二进制，不过是二进制的不同的表现形式。

        数据是以二进制的补码存储的

    2.  1个int类型的变量，在内存中占据4个字节，32位。

        在不考虑正负的情况下，1个int类型的变量可以表示接近43e钟数据。

        为了可以表示正负形，使用最高位来表示这个数的正负性。

        如果最高位是0，那么这个数是1个正数。

        如果最高位是1，那么这个数是1个负数。

        所以一个表述数据的只有31位。

所以，1个int类型的变量

        最小值是:-2147483648 最大值是：2147483647

    3.  原码：

        最高位表示符号位。

剩下的为数，是这个数的绝对值的二进制。

        绝对值：正数的绝对值是自己，负数的绝对值是去掉符号。

    4.  反码：

        正数的反码就是其原码。

        负数的反码就是其原码的基础上，符号位不变，其他位取反。

        10的原码： 00000000 00000000 00000000 00001010

        10的反码： 00000000 00000000 00000000 00001010

        -8的原码： 10000000 00000000 00000000 00001000

        -8的反码： 11111111 11111111 11111111 11110111

    5.  补码：

        正数的补码就是其原码。

        负数的补码就是在其反码的基础上，+1

        10的原码： 00000000 00000000 00000000 00001010

        10的反码： 00000000 00000000 00000000 00001010

        10的补码： 00000000 00000000 00000000 00001010

        -8的原码： 10000000 00000000 00000000 00001000

        -8的反码： 11111111 11111111 11111111 11110111

        -8的反码： 11111111 11111111 11111111 11111000

    6.  任何数据都是以其二进制的补码形式存储在内存中的。

        因为计算机中只有加法没有减法，为了更加低成本的计算出结果，所以使用补码来存储数据。

        因为使用补码来做运算效率是最高的。

 P188-192 按位与预算，按位或运算，按位取反运算，按位异或，按位左移或右移。

    1.位运算：指的是一个二进制数据的每一位来参加运算。

      位运算的前提：是这个数必须是一个二进制。

        注意：

        1.参与运算的二进制数据必须是补码形式。

        2.位运算的结果为运算的结果也是二进制的补码形式

    2.按位与 ：&

        参与按位与的两个二进制数如果都为1，那么结果就为一。

只要有1位为0，那么结果就为0。

    

        3 & 2：

        3的补码：00000000 00000000 00000000 00000011

        2的补码：00000000 00000000 00000000 00000010

        --------------------------------------------

                00000000 00000000 00000000 00000010

        -3 & 4 :

        -3的原码：10000000 00000000 00000000 00000011

        -3的反码：11111111 11111111 11111111 11111100

        -3的补码：11111111 11111111 11111111 11111101

         4的补码：00000000 00000000 00000000 00000100

        --------------------------------------------

                 00000000 00000000 00000000 00000100

        任何数按位与1的结果是：是这个数的最低位。

        偶数的最低位一定是0，奇数的最低位一定是1.

        所以。

如果判断这个数是奇数还是偶数，只要用这个数按位与1就可以了。

        如果结果是1，那么就是奇数，如果结果是0，那么就是偶数。

    3.按位或 ：|

      参与按位或的二进制数据，只要有1位是1，那么结果就为1，只有当两位都是0的时候结果才为0

         3 | 2：

         

         3的补码：00000000 00000000 00000000 00000011

         2的补码：00000000 00000000 00000000 00000010

         --------------------------------------------

                 00000000 00000000 00000000 00000011

         -3 & 4 :

         -3的补码：11111111 11111111 11111111 11111101

          4的补码：00000000 00000000 00000000 00000100

         --------------------------------------------

                  11111111 11111111 11111111 11111101

    4.按位取反 ：~

        单目运算符。

将这个数的二进制数的每一位取反。

            ~3;

        3的补码：00000000 00000000 00000000 00000011

                11111111 11111111 11111111 11111100 补码

                10000000 00000000 00000000 00000011 反码

                10000000 00000000 00000000 00000100 原码 -4

                     int num = ~3 ;

                     printf("num = %d\n",num);

                     输出结果：

                     num = -4

    5.按位异或 ： ^

        参与按位异或的二进制数据的位 如果相同位0 不同则为1.

             3 ^ 2：

             

             3的补码：00000000 00000000 00000000 00000011

             2的补码：00000000 00000000 00000000 00000010

             --------------------------------------------

                     00000000 00000000 00000000 00000001    1

                 int num = 3^2;

                 printf("num = %d\n",num);

                   输出结果：

                 num = 1

        交换两个变量的值:

         int a = 10;

         int b = 20;

         printf("a = %d , b= %d\n",a,b);// a = 10 , b= 20

         a = a ^ b;

         printf("a = %d , b= %d\n",a,b);// a = 30 , b= 20

         b = a ^ b;

         printf("a = %d , b= %d\n",a,b);// a = 30 , b= 10

         a = a ^ b;

         printf("a = %d , b= %d\n",a,b);// a = 20 , b= 10

         

         

         

    6.按位左移运算 ： <<

        参与按位左移运算的二进制数据。

向左移动指定的为数。

低位不够补0，高位溢出就丢弃。

        3 << 2 ;

        3的补码：00000000 00000000 00000000 00000011

           00  000000 00000000 00000000 00000011 00

                00000000 00000000 00000000 00001100   //12

        注意：1.左移运算有可能改变其正负性。

             2.将一个数左移n位，相当于将这个数乘以2的n次方。

    7.按位右移运算 ： >>

         参与按位又移运算的二进制数据。

向左移动指定的为数。

低位溢出就丢弃，高位补符号位。

         3 << 2 ;

         3的补码：00000000 00000000 00000000 00000011

                 00 00000000 00000000 00000000 000000 11

                 00000000 00000000 00000000 00000000   //0

        注意：1.左移运算不可能改变其正负性。

             2.将一个数右移n位，相当于将这个数除以2的n次方。

         

 P193 - 深入变量的细节。

    1.不同类型的变量在内存中占据不同的字节数。

int 4 float 4 double 8 char 1

    2.变量申请的内存空间一定是连续的。

      每一个字节都有一个独一无二的内存地址，是1个十六进制的数。

并且项链的字节的地址一定是连续的。

      2.1 为变量分配字节空间的时候，是从高地址向地地址分配的。

分配的连续的指定字节数的空间。

      2.2 存储在变量中的数据是以数据的二进制补码形式储存进去的。

        

          存储的时候，是低位存储在低字节，高位存储在高字节。

（二进制 最左边是符号位，也就是最高位。

）

      2.3 变量的地址：

        变量的地址是组成这个变量的低字节地址。

        使用&取地址可以取出变量的地址。

        &变量名;这个表达式的结果就是变量的地址。

        要打印地址使用 %p 占位符。

     2.4  声明变量，就会占用内存空间。

        实际上程序在运行的时候，并不是说只有我们的代码才会声明变量。

        系统自己也会在内存申请空间存储数据。

 P194 - int类型的修饰符

    1.作用。

指定int类型的变量在内存中占用的字节数。

    2.short 修饰符：

      被short修饰的int类型的变量是在内存中只占2个字节，16位。

      最小值：-32768 最大值: 32767

        a.要输出的short修饰的int类型的变量，占位符要用 %hd来输出。

        b.如果要声明1个short int类型的变量，那么可以省略int 直接写short;

    3.long 修饰符：

        在32位的 *** 作系统下，被long修饰的int类型的变量内存中占4个字节

        在64位的 *** 作系统下，被long修饰的int类型的变量内存中占8个字节，64位。

            a.要输出的long修饰的int类型的变量，占位符要用 %ld来输出。

            b.如果要声明1个long int类型的变量，那么可以省略int 直接写long;

    4.long long 修饰符：

        在声明一个int类型的时候可以使用long long 来修饰。

        无论在32位系统还是64位系统，都是占8个字节。

            a.要输出的long long修饰的int类型的变量，占位符要用 %lld来输出。

            b.声明的时候可以省略 int.

    8个字节，64位，最高位表符号，63位表数据。

 P195 - 有符号和无符号

    1.  unsigned 修饰符。

无符号数。

        声明int变量的时候为这个int类型的变量加1个修饰符，unsigned 表示这个变量最高位不要来表示符号，而是参与到数据的表示中。

        那么这个变量的最小值变成了0，最大值翻了2倍。

    2.  unsigned int        -->%u

        unsigned short      -->%hu

        unsigned long       -->%lu

        unsigned long long  -->%llu

    3.signed 修饰符。

有符号数。

        表示最高位用来作为符号位，实际上默认就是这样的。

signed写不写都一样。

 P196 - char变量的深入

    1.任何数据在内存中都是以其二进制的补码的形式储存。

    2.字符数据在内存中是如何存储的？

     字符数据在内存中存储的都是这个字符所对应的ascii码的二进制补码。

    3.我们可以直接位char变量赋值一个整数。

     

    4.char 变量是1个有符号的。

最高位表示的是符号位。

    5.%c 读取的时候。

先从变量中读取除存储在变量中的整数，然后再去ascii表中查找对应字符，再显示这个字符。

 P197 - 课程回顾

    文件包含指令，多文件开发，变量存储的简单细节