鹏哥C语言 P15—P24

选择语句

#include <stdio.h>
int main(){
    int input = 0;//输入的值printf("加入比特:>\n");
    printf("那要好好学习吗(1/0)?>:");scanf("3d"&input);
    if (input == 1)
    {
        printf("好offer\n");
    else
    {
        printf("卖红薯\n");
    }
return 0;

if与else后，如果只有一条语句，可以 不加{}。

循环语句
有些事必须一直做，比如：日复一日的学习。

int main(){
    int line = 0;
    //循环
    while(line<30000)
    {
            printf("写代码:%d\n",line);
            line++;
    }
    if (line == 30000){
    printf("好offer\n");
    }
    return 0;
 }

函数

Add(int x,int y)
{
    int z=0;
    z=x+y;
    return z;
}
int main()
{
    int num1=0;
    int num2=0;
    scanf("%d%d",&numl,&num2);
    int sum = numl + num2;
    //函数的方式解决
    int sum = Add (numl，num2) ;
    printf("%dn", sum) ;
    return 0;
}

函数的特点是简化代码，代码复用。

数组
要存储1-10的数字，怎么存储？
C语言中给了数组的定义：一组相同类型元素的集合。
数组是用下标来访问的——arr[0]访问的是第一个元素。
数组定义

//定义一个整型数组，最多放10个元素
int arr[10] = {1,2,3,4,5,6,7,8,9,10};
//不完全初始化，剩余的默认为0
char ch[5] = {'a','b','c'};
数组的使用
int arr[10] = {1,2,3,4,5,6,7,8,9,10};
int i=0;
while(i<10)
{
    printf("%d",arr[i]);
    i++;
}

操作符

• 算术操作符：+ - * / %

int a = 9/2;
float a = 9/2;
//输出结果都为4 float后有小数点后六位
float a = 9.2/2;
float a =9/2.0;
//答案才会为4.500000 

• 位移操作符：>> <<

int mian()
{
    int a = 2;
    int b = a << 1;
    printf("%d\n",b);
    return 0;
}

移动的是二进制位：

• 写出2的二进制（共四个字节写32位）

  00000000 00000000 00000000 00000010

• 向左移动一位，右边空位补0（左移不管什么情况都是补0），得4。

  00000000 00000000 00000000 00000100

• 位操作符：& ^ |

• 赋值操作符：= += -= *= /= &= ^= l= >>= <<=

• 单目操作符：只有一个操作数（如：!a —— a+b:两个操作数 双目）
  !：逻辑反操作
  -：负值
  +：正值
  &：取地址

• sizeof：操作数的类型长度
  是操作符，计算类型或变量的大小。
  sizeof后面的（）可以省略，所以它不是函数，但通常使用时不省略。
  计算数组大小时，计算的是数组的总大小，单位是字节。

int main()
{
    int arr[10]={0};
    printf("%d\n",sizeof(arr));//10*4=40
    printf("%d\n", sizeof (arr[0]));//4
    int sz=sizeof(arr)/sizeof(arr[0]);
    printf("%d \n", sz);//计算数组元素个数
    return 0;
}

• ~ （以字节为单位)对一个数的二进制按位取反——符号位也变
  在内存中进行计算，得到的值也为内存中的值，即为存储在内存里的二进制形式的补码，以%d形式，打印出来应为原码。若取反后最高位为1，则应从补码反推回原码。

int main()
{
    int a=0;
    printf("%d\n",~a); //结果为-1
    return 0;
}

整数a=0；其二进制表示为：00000000 00000000 00000000 00000000
~a则为：11111111 11111111 11111111 11111111
整数在内存中存储的是补码，即反码+1。

正整数：原码、反码、补码相同。

-1在内存中的存储：
原码：10000000 00000000 00000000 00000001
（最高位为符号位，0为正，1为负。）
反码：11111111 11111111 11111111 1111110
（原码——反码式，最高位不变。）
补码：11111111 11111111 11111111 1111111

• –前置、后置–
• ++前置、后置++
  前置：先＋/ - 后使用
  后置：先使用后＋/ -

int main()
{
    int a = 10;
    int b = ++a;
    printf("%d\n",b); //结果为11
    printf("%d\n",a); //结果为11
    //后置++
    b = a++;
    printf("%d\n",b); //结果为10
    printf("%d\n",a); //结果为11
    return 0;
}

• ☆间接访问操作符(解引用操作符)
• (类型)强制类型转换
• 关系操作符：> >= < <= != ==
• 逻辑操作符
  && 逻辑与一个为假则为假，两个同时为真才为真。
  || 逻辑或一个为真则为真，两个都假才为假。
  类似：描述显示生活中并且和或者的关系

int mian()
{
    int a = 3;
    int b = 5;
    int c = a && b; //并且
    if(a && b)
    {
       printf("%d\n",c); //结果为1
       printf("%d\n",);     
    }
    return 0;
}

非0为真，所以a/b均为真，所以a&&b为真。

• 条件操作符（三目操作符）
  exp1？exp2：exp3
  表达式1如果成立，表达式2计算，整个表达式的结果为2的结果；如果表达式1不成立，则计算表达式3，整个表达式的结果为3。

int main()
{
    int a = 0;
    int b = 3;
    int max = 0;
    if(a>b){
        max=a;    
    }else{
        max=b;    
    }
    max=a>b?a:b;
    return 0;
}

• 逗号表达式
  exp1,exp2,exp3…expn

int main(){
    //(2,4+5,6);
    int a=0;
    int b=3;
    int c=5;
    int d=(a=b+2,c=a-4,b=c+2);
    //从左向右依次计算，结果为最后一个表达式的结果。
    return 0;
}

• 下标引用、函数调用和结构成员
  []下标引用操作符
  () 函数调用操作符
  . 指针
  ->指针

常见关键字
特点：C语言提供的，不能自己创建关键字；
不能用作变量名；

auto break char const continue default do double else enum extern float for goto if int long register return short signed sizeof static case struct switch typedef union unsigned void volatile while

1. auto是用于修饰局部变量的，而局部变量一般都是自动创建、自动销毁的，所以会把auto省略掉。

2. register：寄存器关键字

   计算机中数据可以存放在哪里呢？
   寄存器更小
   高速缓存几十MB
   内存8G-16G
   硬盘500G-买的
   网盘2T-免费的
   越往上，造价越高，速度越快，空间越小。

int main()
{
    //大量/频繁被使用的数据，想放在寄存器中，提升效率
    register int num = 100; //建议num的值存放在寄存器
    //只是建议，最终存放位置由编译器说了算
    return 0;
}

CPU先往寄存器读取数据，如果没有，再一步步往下读取。

3. typrdef：类型重新命名。

typedef unsigned int u_int;
int main (){
    unsigned int num = 100;
    u_int num2 =100;
    return 0;
}

4. static是用于修饰变量和函数的

• 修饰局部变量-静态局部变量

  改变了局部变量的生命周期（本质上是改变了变量的存储类型）

• 修饰全局变量-静态全局变量

  原全局变量可以使用在整个工程中，只需用extren引入，而被static修饰的使全局变量只能在自己所在的源文件内部使用。
  全局变量，在其他源文件内部可以被使用，是因为全局变量具有外部链接属性。但是被static修饰之后，就变成了内部链接属性，其他源文件就不能链接到这个静态的全局变量了。

• 修饰函数-静态函数
  
  上图：正常情况下全局函数的使用
  
  static修饰函数，使得函数只能在自己所在的源文件内部使用，不能在其他源文件内部使用。
  本质上: static是将函数的外部链接属性变成了内部链接属性!（和static修饰全局变量一样 )

void test()
{
    /*
    int a = l;
    a++;
    printf ("%d ", a); //输出结果为10个2
    */
    static int a = l;
    a++;
    printf ("%d ", a); //输出结果为2—11
}
int main()
{
    int i = 0;
    while (i<10)
    {
         test();
         i++;   
    }
    return 0;
}

正常情况下，进入函数时，a被创建，出函数时销毁。
static修饰的变量a，在出text函数时并没有被销毁，即a的生命周期变长了。

5. define和include是预处理指令，不是关键字。

• define定义宏

#define ADD(X,Y) X+Y
int main()
{
    printf("%d\n",ADD(2,3)); //输出结果为5
    printf("%d\n",4*ADD(2,3)); //输出结果为11
    //4*2+3
    return 0;
}