以下是程序调试结果截图。
?
?
?
?
?
?
?
?
?整数在内存中存放的是二进制的补码
?
?
?
?
?
?
?
?
?
?
?
?
?
?
注意：关键字不能自己创建，变量名不能是关键字?
?
?
?
?
?
源代码：?
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
//int main()
//{
//?? ?int a = 7 / 2;
//?? ?int b = 7 % 2;
//?? ?float f = 7 / 2.0;
//?? ?printf("%d\n", a);
//?? ?printf("%d\n", b);
//?? ?printf("%f\n", f);
//
//?? ?return 0;
//}
//int main()
//{
//?? ?int a = 12;//二进制数为1100。a是整型，4个字节，32bit
//?? ?//a变量为00000000000000000000001100
//?? ?//左移一位0000000000000000000000011000.故b=24
//?? ?int b = a << 1;//左移操作符
//?? ?//移位指的是移动二进制位
//?? ?printf("b=%d\n", b);
//
//?? ?return 0;
//}
//& 按（2进制）位与
//^按（2进制）位异或
//| 按（2进制）位或
//int main()
//{
//?? ?int a = 3;//000000000000000000000000000011
//?? ?int b = 5;//000000000000000000000000000101
//
//?? ?int c = a & b;//000000000000000000000000000001按位与的结果：对应的二进制位，有0则为0，两个同时为1，才是1
//?? ?int d = a | b;//000000000000000000000000000111按位或的结果：对应的二进制位，有1则为1，两个
//?? ?int e = a ^ b;//000000000000000000000000000110按位异或的结果：相同为0，相异为
//?? ?printf("%d\n", c);
//?? ?printf("%d\n", d);
//?? ?printf("%d\n", e);
//
//?? ?return 0;
//}
//int main()
//{
//?? ?int a = 10;//初始化
//?? ?float score = 0.0;
//?? ?a = 45;//赋值
//?? ?score = 95.5;//95.5直接写出来的浮点数默认是double类型的,这样写可能会报错
//?? ?//95.5f—指定为float类型
//?? ?return 0;
//}
//int main()
//{
//?? ?int a = 10;
//?? ?a = a + 5;
//?? ?a += 5;//复合赋值符
//?? ?a -= 5;
//}
//int main()
//{
?? ?//3 + 5;//操作符
?? ?//3和5是操作数
?? ?//3是左操作数
?? ?//5是右操作数
?? ?//+是双目操作符
?? ?//单目操作符—只有一个操作数的操作符
?? ?//int flag = 5;
?? ?C语言是如何表示真假的？
?? ?0就是假，非0就是真
?? ?flag为真就打印hehe
?? ?//if (flag)
?? ?//{
?? ?//?? ?printf("hehe\n");
?? ?//}
?? ?flag为假打印haha
?? ?//if (!flag)
?? ?//{
?? ?//?? ?printf("haha\n");
?? ?//}
?? ?//int flag = 0;
?? ?//int b = !flag;
?? ?//printf("%d\n", b);
?? ?//return 0;
//}
//sizeof是操作符(也叫运算符） 不是函数?
//int main()
//{
//?? ?int a = 10;
//?? ?printf("%d\n", sizeof(int));//4
//?? ?printf("%d\n", sizeof(a));//4
//?? ?printf("%d\n", sizeof a);//4
//
//?? ?return 0;
//}
//~-按二进制位取反:0变成1，1变成0.
//如果一个整数存储在内存中的二进制序列是：
//00010101001010101000101010100010
//11101010110101010111010101011101
//计算机识别的是二进制
//整数存放在内存中也存放的是二进制
//整数在内存中存放的是二进制的补码
//整数的二进制怎么表示？整数的二进制表示方式有3种：
//原码—直接按照数字的正负转换成二进制就是原码
//反码—原码的符号位不变，其他位按位取反，就是反码
//补码—反码+1，就是补码
//正整数的原码，反码，补码是相同的
//负整数的原码，反码，补码要计算
//规定：
//对于有符号整数，二进制的最高位是符号位。
//最高位是0，表示正数。最高位是1，表示负数
//int main()
//{
?? ?//int a = 0;//32bit
?? ?//00000000000000000000000000000000-原码
?? ?//00000000000000000000000000000000-反码
?? ?//00000000000000000000000000000000-补码
?? ?//int b = -1;
?? ?//10000000000000000000000000000001-原码
?? ?//11111111111111111111111111111110-反码
?? ?//11111111111111111111111111111111-补码
?? ?//int a = 0;
?? ?//00000000000000000000000000000000-补码
?? ?//11111111111111111111111111111111-取反后的结果为补码，是存放在内存中的
?? ?//11111111111111111111111111111110-得到的是反码
?? ?//10000000000000000000000000000001-原码
?? ?//printf("%d\n", ~a);//%d是想打印出来~a的结果
?? ?//return 0;
//}
//int main()
//{
//?? ?int a = 10;
//?? ?int b = a++;//后置++,先使用再++
//?? ?int c = ++a;//前置++，先++再使用
//?? ?printf("%d\n", a);//12
//?? ?printf("%d\n", b);//10
//?? ?printf("%d\n", c);//12
//
//
//?? ?return 0;
//}
//int main()
//{
//?? ??? ?int a = 10;
//?? ??? ?//int b = a--;//a的值先赋给b，然后a再进行计算
//?? ??? ?int b = --a;//a先减，然后把值赋给b
//
//?? ??? ?printf("%d\n", a);
//?? ??? ?printf("%d\n", b);?
//
//
//?? ??? ?return 0;
//}
//int main()
//{
//?? ?int a = (int)3.14;
//?? ?printf("%d\n", a);
//
//?? ?return 0;
//}
//int main()
//{
//?? ?int a = (3 > 5);
//?? ?printf("%d\n", a);
//?? ?if (3 > 5)
//?? ?{
//?? ??? ?printf("hehe\n");
//?? ?}
//?? ?return 0;
//}
//exp1 ? exp2 : exp3 ?//条件操作符（三目操作符）
//int main()
//{
//?? ?int a = 10;
//?? ?int b = 20;
//?? ?int max = 0;
//?? ?//if (a > b)
//?? ??? ?//max = a;
//?? ?//else
//?? ??? ?//max = b;
//?? ?max = (a > b) ? (a) : (b); ? ?//(与上面的if else语句相同）?
//?? ?printf("%d\n", max);
//
//
//?? ?return 0;
//}
//逗号操作符
//int main()
//{
//?? ?int a = 3;
//?? ?int b = 5;
//?? ?int c = 6;
//?? ?//逗号表达式-从左往右依此计算，整个表达式的结果是最后一个表达式的结果。
//?? ?int d = (a -= 2, b = a + c, c = a - b);
//?? ?// ? ? ? a=1 ? ? b=7 ? ? ? ?c=-6
//?? ?printf("%d\n", d);
//?? ??
//?? ?return 0;
//}
//int main()
//{
//?? ?int arr[10] = { 1,2,3,4,5,6 };
//?? ?arr[4];//[]-就是下标引用操作符
//?? ?//[]的操作数是arr和4
//?? ?return 0;
//}
//int Add(int x, int y)//int表示函数调用完成之后返回一个整数
//{
//?? ?int z = x + y;
//?? ?return z;
//}
//void test()//void是无的意思，就是说函数test调用之后什么都不用返回
//{
//?? ?printf("test\n");
//}
//int main()
//{
//?? ?int a = 10;
//?? ?int b = 20;
//?? ?int sum = Add(a, b);//函数调用，()就是函数调用的操作符
//?? ?//()的操作数是Add,a,b
//?? ?printf("sum = %d", sum);
//?? ?test;//()函数调用操作符
//?? ?//()的操作数是test
//?? ?return 0;
//}
//C语言的关键字：auto ?break ?case ?char ?const ?continue ?default ?do ?double else ?enum?
//extern float ?for ?goto ?if ?int ?long ?register ??return ?short ?signed
//sizeof ?static struct ?switch ?typedef union ?unsigned ?void ?volatile ?while
//注意：关键字不能自己创建，变量名不能是关键字
//循环:break,continue，do,for，goto语句，while
//分支：case,default,if,else,goto语句
//类型：char,double,float,int,long，short，signed(有符号和无符号的限制),unsigned(无符号型)，void
//自定义类型：enum-枚举,struct,union
//声明外部变量：extern
//寄存器-register
//返回-return-使用在函数中
//计算内存大小-sizeof
//静态-static
//类型重定义(重命名)-typedef
//Linux系统部分-volatile
//int main()
//{
//?? ?auto int a = 10;//auto经常被省略了
//?? ?return 0;
//}
//typedef unsigned int unit;
//int main()
//{
//?? ?unsigned int age = 10;
//?? ?unit age2 = 20;
//?? ?return 0;
//}
//static有3种用法：
//1.static修饰局部变量:
//（使得局部变量出了自己的范围也不销毁，其实是改变了局部变量的生命周期）
//但是作用域还是局部的
//2.static修饰全局变量：全局变量本身是具有外部链接属性的
//但是static修饰全局变量，会使得全局变量失去外部链接属性，变成内部链接属性
//所以static修饰的全局变量，只能在自己所在的.c文件中使用
//3.static修饰函数
//函数默认具有外部链接属性
//但是被static修饰之后，会使得函数失去外部链接属性变成内部链接属性
//所以static修饰的函数只能在自己的.c文件内部使用，不能在其他文件使用
//void test()
//{
//?? ? static int a = 1;
//?? ?a++;
//?? ?printf("%d\n", a);
//}
//int main()
//{
//?? ?int i = 0;
//?? ?while (i < 10)
//?? ?{
//?? ??? ?test();
//?? ??? ?i++;
//?? ?}
//?? ?return 0;
//}