标C编程基础02

scanf函数可以从键盘上读取数据并记录到变量中。为了使用这个函数也需要在文件开头使用如下的预处理指令
#include <stdio.h>
scanf函数使用的时候所需要的初始数据和printf函数非常类似。它同样也支持多种占位符。

char类型可以表示256个不同的整数，在我们的计算机上是从-128到127。这种类型的变量通常当作字符使用。

ASCII码表记录了字符和数字之间的对应关系。
'c' - 'a' 等于 'C' - 'A'
'2' - '0' 等于 2 - 0
unsigned char类型表示无符号字符，它的范围是0到255。

sizeof关键字可以用来计算一个数据类型或者一个变量所占空间大小是多少个字节。sizeof关键字可以用于对一个表达式的计算结果求大小，但是这个表达式在运行过程中不会真正被执行。

short,unsigned short  表示2的16次方个不同的整数
int, unsigned int     表示2的32次方个不同的整数
long, unsigned long   表示2的32次方个不同的整数

unsigned char 占位符是%hhu
short 占位符是%hd
unsigned short占位符是%hu
unsigned int 占位符是%u
long 占位符是%ld
unsigned long 占位符是%lu

float是单精度浮点数，double是双精度浮点数
float 占位符是%f或%g
double 占位符是%lf或%lg

计算机使用一组0和1来表示所有数字，这种方式叫做二进制。每个字节由8个二进制数位构成，每个字节所表示的数字由其中每个数位上的1转换成10进制以后求和得到。每个字节中的八个数位从右到左进行编号，编号从0开始，每个数位上的1转换成十进制就是2的编号次方。
01100111 = 2^6 + 2^5 + 2^2 + 2^1 + 2^0 = 103

十进制转换二进制
87 = 2^6 + 2^4 + 2^2 + 2^1 + 2^0 =
01000000 + 00010000 + 00000100 + 00000010 + 00000001 = 01010111

计算机内部以补码方式记录所有数字的二进制形式。非负数的补码就是原码。负数的补码是正数的补码按位求反再加一得到的。
31的补码是00011111，按位求反后得到11100000，再加一以后得到11100001，这就是-31的补码。最高一位是1后面都是0表示这个类型的最小整数。
数字补码的最左位又称为符号位，0表示数字非负，1表示数字是负的。

 

把二进制数字从右向左每三位一组，每组使用一个0到7之间的数字代替得到的结果叫做八进制。

把二进制数字从右向左每四位分成一组，每组使用0到9以及a到f中的一个来表示得到的结果叫做十六进制。

单目运算符是只需要一个数字就可以完成的计算。
双目运算符是需要两个数字才能完成的计算。
三目运算符是需要三个数字才能完成的计算。

+,-,*,/,%分别代表加，减，乘，除以及取余的计算。

 

赋值运算符用于对变量赋值，可以和其他运算符合并成为复合运算符（参考例子）

++(自增运算符)和--(自减运算符)都是单目运算符，可以对变量内容进行加一，减一操作。他们既可以放在变量名前面也可以放在变量名后面。不要在同一条语句中对同一个变量进行多次自增或自减运算，因为结果不确定。可以对浮点数进行自增或自减运算

。

逻辑表达式表示一个数字的计算过程，结果只能是真（用1代表）或者假（用0代表）。逻辑表达式中使用的运算符叫做逻辑运算符。==（等于），！=（不等），>(大于)，<(小于)，>=(大于等于)和<=（小于等于）。

&&(与),||(或)也是逻辑运算符，他们可以把两个逻辑运算表达式并成一个。当原来的两个逻辑表达式计算结果都是真的时候用&&合并得到的结果表达式结果也是真，否则合并得到的结果表达式结果是假。只要原来的两个逻辑表达式中有一个计算结果为真则用||合并得到的结果表达式结果就是真，否则新表达式的结果就是假。
所有整数都可以当逻辑表达式使用，0表示假其他都表示真。
&&和||都具有短路特性(参考练习)
!表示逻辑非，是一个单目运算符。

 

eg:/*
    浮点数练习
*/
#include <stdio.h>
int main() {
    printf("sizeof(float)是%d,sizeof(double)是%d\n", sizeof(float), sizeof(double));
    return 0;
}

eg:/*
    进制练习
*/
#include <stdio.h>
int main() {
    int shu_zi = 0;
    printf("%d 0%o 0x%x 0X%X\n", 15, 15, 15, 15);
    printf("%d %d %d\n", 15, 017, 0xf);
    printf("%p\n", &shu_zi);
    return 0;
}

eg:/*
  scanf练习
*/
#include <stdio.h>
int main() {
    int shu_zi = 1000, shu_zi_1 = 400;
    printf("请输入两个数字：");
    scanf("shu_zi = %d shu_zi_1 = %d", &shu_zi, &shu_zi_1);
    printf("结果是%d\n", shu_zi - shu_zi_1);
    return 0;
}

eg:/*
    char类型练习
*/
#include <stdio.h>
int main() {
    char zi_fu = 'c';
    printf("%c\n", zi_fu);
    printf("sizeof(char)是%d,sizeof(zi_fu)是%d\n", sizeof(char), sizeof(zi_fu));
    printf("大小是%d\n", sizeof(zi_fu = 'd'));
    printf("zi_fu是%c\n", zi_fu);
    return 0;
}

eg:/*
    四则运算符练习
*/
#include <stdio.h>
int main() {
    printf("17 / 4是%d\n", 17 / 4);
    //printf("17 / 4.0f是%d\n", 17 / 4.0f); //参与除法计算的数字中只要有一个是浮点数则结果就是浮点数
    printf("4.0f / 0.0f是%f\n", 4.0f / 0.0f);
    printf("17 %% 4是%d\n", 17 % 4);
    printf("-17 %% 4是%d\n", -17 % 4);
    printf("17 %% -4是%d\n", 17 % -4);
    return 0;
}

eg:/*
    整数类型练习
*/
#include <stdio.h>
int main() {
    short s_shu_zi = 0;
    unsigned short us_shu_zi = 65536;  //变量有范围，超过范围的数字赋值给变量会发生截断
    int i_shu_zi = 0;
    long l_shu_zi = 0;
    printf("sizeof(short)是%d,sizeof(s_shu_zi)是%d\n", sizeof(short), sizeof(s_shu_zi));
    printf("sizeof(int)是%d,sizeof(i_shu_zi)是%d\n", sizeof(int), sizeof(i_shu_zi));
    printf("sizeof(long)是%d,sizeof(l_shu_zi)是%d\n", sizeof(long), sizeof(l_shu_zi));
    printf("us_shu_zi是%hu\n", us_shu_zi); 
    return 0;
}

eg:/*
     逻辑运算符练习
*/
#include <stdio.h>
int main() {
    int shu_zi = 0;
    printf("3 == 5是%d\n", 3 == 5);
    printf("3 < 7 < 5是%d\n", 3 < 7 < 5); //不能用这种方式表示7位于3和5之间，两个逻辑运算符计算有先后顺序
    printf("3 < 7 && 7 < 5是%d\n", 3 < 7 && 7 < 5);
    printf("7 < 5 || 9是%d\n", 7 < 5 || 9);
    0 && ++shu_zi;   //&&的短路特性，前一个表达式结果为假则后面的表达式不计算
    printf("shu_zi是%d\n", shu_zi);
    1 || ++shu_zi;   //||的短路特性，如果前一个表达式结果为真则后面不计算
    printf("shu_zi是%d\n", shu_zi);
    printf("!9是%d\n", !9);
    return 0;
}

eg:

/*
    赋值操作符练习
*/
#include <stdio.h>
int main() {
    int shu_zi = 0, shu_zi_1 = 0;
    printf("结果是%d\n", shu_zi = 5);  //赋值语句可以被当成数字使用，数字就是赋值的结果数字
    printf("shu_zi是%d\n", shu_zi);
    shu_zi = shu_zi_1 = 7;
    printf("shu_zi是%d,shu_zi_1是%d\n", shu_zi, shu_zi_1);
    printf("(7,3)是%d\n", (7,3));  //，也是一个运算符，计算结果是后一个表达式的计算结果
    shu_zi = 9, 10;  //赋值操作符的优先级很低，但是比,运算符优先级高
    printf("shu_zi是%d\n", shu_zi);
    shu_zi = (9, 10);
    printf("shu_zi是%d\n", shu_zi);
    shu_zi *= 2 + 3;  //相当于shu_zi = shu_zi * (2 + 3)。复合赋值操作符的优先级和赋值操作符一样
    printf("shu_zi是%d\n", shu_zi);
    return 0;
}

 

eg:

/*
    自增，自减运算符练习
*/
#include <stdio.h>
int shu_zi_2;
int main() {
    int shu_zi = 0, shu_zi_1 = 0;
    double shu_zi_3 = 0.0;
    shu_zi++;
    printf("shu_zi是%d\n", shu_zi);
    ++shu_zi;
    printf("shu_zi是%d\n", shu_zi);
    shu_zi--;
    printf("shu_zi是%d\n", shu_zi);
    --shu_zi;
    printf("shu_zi是%d\n", shu_zi);

    shu_zi_1 = 3;
    shu_zi = shu_zi_1++;   //后++运算符的优先级比赋值操作符还要低
    printf("shu_zi是%d，shu_zi_1是%d\n", shu_zi, shu_zi_1);

    shu_zi_1 = 3;
    shu_zi = ++shu_zi_1;   //前++运算符的优先级接近最高
    printf("shu_zi是%d，shu_zi_1是%d\n", shu_zi, shu_zi_1);

    shu_zi_1 = 3;
    shu_zi = shu_zi_1++ + ++shu_zi_1;
    printf("shu_zi是%d，shu_zi_1是%d\n", shu_zi, shu_zi_1);

    shu_zi_2 = 3;
    shu_zi = shu_zi_2++ + ++shu_zi_2;
    printf("shu_zi是%d，shu_zi_2是%d\n", shu_zi, shu_zi_2);

    shu_zi_3 = 4.6;
    shu_zi_3++;
    printf("shu_zi_3是%lg\n", shu_zi_3);
    return 0;
}