//#include
//int main()
//{
// int a = 5/2;//5除以2，商2余1，"/"代表的是商，所以打印结果是2
// printf("%dn", a);
// return 0;
//}
//#include
//int main()
//{
// int a = 5%2;//5除以2，商2余1，"%"代表的是取模，所以打印结果是1
// printf("%dn", a);
// return 0;
//}
//#include
//int main()
//{
// //移位操作符其实是移的是二进制位
// int a = 1;
// //一个整形占4个字节--32个比特位
// //那么赋值给a的其实是‘0000000000000000000001’
// int b = a << 1; //用b接收a移动后的值
// //a向左移动一位。就是将二进制中的所有数字向左移动1位后面补一个0。变为‘0000000000000000000010’
// printf("%dn", b);//打印后的结果为2
// printf("%dn", a);//a的值不变还是1
// return 0;
//}
//#include
//int main()
//{
// //位操作符。这里的位仍然代表的是2进制位
// //&--按位与
// //|--按位或
// //^--按位异或
// int a = 3;
// int b = 5;
// int c = a&b;
// //将a转换到二进制位是011
// //将b转化为二进制位是101
// //“按位与”中"与"的意思其实就是并集
// //0 1 1
// //1 0 1
// //在第一列有0和1,0为假1为真，那么并集就为假，两者取并集的结果就是0。以此类推，第二列的结果也为0，第三列的结果1和1都为真，则取并集后结果为1。
// //那么a&b的结果就是001
// printf("%dn", c); //打印出来的结果是1
// return 0;
//}
//#include
//int main()
//{
// int a = 3;
// int b = 5;
// int c = a|b;
// //将a转换到二进制位是011
// //将b转化为二进制位是101
// //“按位或”的意思就是一列数之间只要有一个为真那么就为真
// //0 1 1
// //1 0 1
// //在第一列有0和1,0为假1为真,那么“按位或”计算过后的结果就是1
// //a|b的结果就是111
// printf("%dn", c);//打印出来的结果是7
// return 0;
//}
//#include
//int main()
//{
// int a = 3;
// int b = 5;
// int c = a^b; //'^'的意思是异或
// //异或的意思：对应的二进制位相同，则为0；对应的二进制位相异，则为1.
// //0 1 1
// //1 0 1
// //第一列0和1相异那么值为1，第二例1和0相异那么值为1，第三列1和1相同那么值为0
// //"a^b"的结果就是110
// printf("%dn", c); //打印出来的结果就是6
// return 0;
//}
//#include
//int main()
//{
// int a = 10; //'='-->赋值 '=='-->判断相等
// int a += 10; //这行代码的意思是"int a = a + 10"
// int a -= 20;//这行代码的意思是"int a = a - 20"
// int a &= 2; //这行代码的意思是"int a = a&2"
// return 0;
//}
//#include
//int main()
//{
//
// int a = 10;
// printf("%dn", a); //!的作用是把真变成假，把假变成真
// //在C语言中0代表假，其余一切非0数字代表真
// printf("%dn", !a); //！将a逻辑反操作，本来a=10为真，加上！后a就变为假值为0
// return 0;
//}
//#include
//int main()
//{
// int a = -2;//对2进行取负
// int b = -a;//对a进行取负
// int c = +3;//+正号通常都会省略
// return 0;
//}
//#include
//int main()
//{
// int a = 10;
// //sizeof计算的是变量或者类型所占空间的大小，单位是字节
// printf("%dn", sizeof(a));//变量a为整形，占四个字节的大小
// printf("%dn", sizeof(long long));
// return 0;
//}
//#include
//int main()
//{
// int arr[10] = {0}; //十个整形元素的数组
// int sz = 0;
// //10*sizeof (int) = 40
// printf("%dn", sizeof(arr));
// //计算数组元素的个数
// //数组总大小除以每个元素的大小
// sz = sizeof(arr)/sizeof(arr[0]);//sizeof(arr[0])第一个元素的大小，sizeof(arr)总元素的大小
// printf("sz = %dn", sz);
// return 0;
//}
//#include
//int main()
//{
// int a = 0;//4个字节，32个比特位
// int b = ~a;//b是有符号的整形
// // ~ 按位取反（这里的位依然代表二进制位），例如：一个二进制数1010在取反之后变为0101
// //00000000000000000000000000000000
// //11111111111111111111111111111111 //在这里如果第一个数字为1则代表的是负号，如果第一个数字为0则代表的是正号。最高位为符号位
// //负数在内存中存的是补码
// printf("%dn", b);//我们使用的、打印的是这个数的原码
// //计算过程：原码最高位不变其余位取反得到反码，反码加1得到补码
// //11111111111111111111111111111111(补码)
// //11111111111111111111111111111110（反码）
// //10000000000000000000000000000001(原码)最高位是1代表负数
// //所以打印出来的是-1
// return 0;
//}
// 只要是整数，内存中存的都是二进制的补码
//正数-->原码、反码、补码 相同
//负数-->存的是补码
//#include
//int main()
//{
// int a = 10;
// int b = a++;//后置++。意思就是先把a的值赋给b，然后再让a+1
// printf("a = %d b = %d", a, b); //所以打印出来的是a = 11，b = 10.
// return 0;
//}
//#include
//int main()
//{
// int a = 10;
// int b = ++a;//前置++。意思就是先让a+1，然后再赋值给b
// printf("a = %d b = %d", a, b); //所以打印出来的是a = 11，b = 11.
// return 0;
//}
//#include
//int main()
//{
// int a = 10;
// int b = a--;//后置--。意思就是先把a的值赋给b，然后再让a+1
// printf("a = %d b = %d", a, b); //所以打印出来的是a = 9，b = 10.
// return 0;
//}
//#include
//int main()
//{
// int a = 10;
// int b = --a;//前置--。意思就是先让a-1，然后再把a的值赋给b
// printf("a = %d b = %d", a, b); //所以打印出来的是a = 9，b = 9.
// return 0;
//}
//#include
//int main()
//{
// //(类型) 强制类型转换
// int a = (int)3.14;//将3.14这个double类型的数据强制转换为int类型
// printf("%dn", a);
// return 0;
//}
//#include
//int main()
//{
// //C语言中0表示假，一切的非0数值表示真
// int a = 3;
// int b = 5;
// int c = a && b; //a为真，并且b也为真，那么&&为真,所以说c也为真，c打印出来的结果默认为1
// printf("c = %dn", c);
// return 0;
//}
//#include
//int main()
//{
// //C语言中0表示假，一切的非0数值表示真
// int a = 0;
// int b = 5;
// int c = a && b; //a为假，并且b也为真，那么&&为假,所以说c也为假，c打印出来的结果就为0
// printf("c = %dn", c);
// return 0;
//}
//#include
//int main()
//{
// //'||'为逻辑或，只要有一个为真那么就为真
// int a = 0;
// int b = 5;
// int c = a || b;
// printf("c = %dn", c);
// return 0;
//}
//#include
//int main()
//{
// int a = 10;
// int b = 20;
// int max = 0;
// max = (a>b ? a : b);
if(a>b)
max = a;
else
max = b;
printf("")
// printf("max = %dn", max);
// return 0;
//}
//#include
//int Add(int x, int y)
//{
// int z = 0;
// z = x + y;
// return z;
//}
//int main()
//{
//
// int a = 10;
// int b = 20;
// int sum = Add(a, b);//这里的"()"为函数调用操作符
// return 0;
//}
//#include
//int main()
//{
// auto int a = 10;//局部变量。因为a这个变量在大括号开始时自动生效，在大括号结束时自动销毁，多也叫做自动变量。前面的auto一般省略
// return 0;
//}
//#include
//int main()
//{
// //int-->定义有符号变量
// unsigned int num = -1; //unsigned-->定义无符号变量，也就是永远都是正值。即使赋给num的是一个负值，系统也默认它为正值
// printf("%dn", num);
// return 0;
//}
//#include
//int main()
//{
// //struct --> 结构体关键字
// //typedef --> 类型定义
// //union --> 联合体/共用体
// //void --> 无/空
// return 0;
//}
//#include
//int main()
//{
// //typedef -->类型定义 -->类型重定义
// typedef unsigned int u_int;//将"unsinged int"重新定义为"u_int",这样在使用的时候比较容易
// u_int num = -2;
// printf("%dn", num);
// return 0;
//}
//#include
1. static-->修饰局部变量
局部变量的生命周期变长
//void test()
//{
// static int a = 0;// a 是一个静态的局部变量
// //加上static之后会把a++后的结果给累积下,保存上一次留下的值. 否则a每次输入的时候都是0，a++后的结果都是1
// a++;
// printf("a = %dn", a);
//}
//int main()
//{
// int i = 0;
// while(i < 5)
// {
// test(i);
// i++;
// }
// return 0;
//}
#include
int sum(int a)
{
int c = 0;
static int b = 3; //将b每次计算过后的值都保存下来用于下一次循环的计算
c += 1; // c += 1;等价于 c =c + 1
b += 2;
return (a + b + c); // 将a + b + c的值传给d
}
int main()
{
int d = 2;
int i;
for(i = 0; i < 5; i++)
{
printf("%dn", sum(d));
}
return 0;
}
//#include
2. static-->修饰全局变量
缩小了全局变量的作用域 -- 让静态的全局变量只能在自己所在的源文件内部使用，而在一个项目的其他源文件内部无法使用
//static int g_val = 2020;
//int main()
//{
// printf("g_val = %dn", g_val);
// return 0;
//}
//#include
3. static-->修饰全局变量
改变了函数的链接属性
一个正常函数的链接属性是外部连接
前面加上static之后属性就改为了内部链接，也就是说只能在一个他所在的源文件内部使用，不能在同一项目的其他源文件使用。
//int Add(int x, int y)
//{
// int z = 0;
// z = x + y;
// return z;
//}
//int main()
//{
// int a = 10;
// int b = 20;
// int sum = Add(a, b);
// printf("sum = %dn", sum);
// return 0;
//}
//#include
//#define MAX 100// #define 定义标识符常量
//int main()
//{
// int a = MAX;
// printf("%dn", a);
// return 0;
//}
//#include
#define可以定义宏。宏-->在标识符常量上加上了参数
//#define MIN(x, y) (x > y? y: x)// 前面定义的宏会被替换为后面设置的函数。也就是“MAX(x, y)”被替换为“(x > y? x: y)”
// //这里复习一下三目操作符
// // "?"之前的判断如果成立的话输出结果为 x，如果不成立输出结果为 y
//int main()
//{
// int a = 10;
// int b =20;
// int min = MIN(a, b);
// // max = (a>b?a:b)
// printf("min = %dn", min);
// return 0;
//}
//define 定义标识符常量
//#define MAX 1000
//define 定义宏
//#include
//#define ADD(x ,y) ((x) + (y))
//int main()
//{
// int sum = ADD(2, 3);
// printf("sum = %dn", sum);
// sum = 10*ADD(2,3);
// printf("sum = %dn", sum);
// return 0;
//}
//#include
//int main()
//{
// int a = 10;//在内存中申请4个字节的空间
// int* p = &a; //"&"取地址符号。这句话的意思就是取出a的地址
// //有一种变量是用来存放地址的，这种变量就称为指针变量。用 int* 来赋值
// printf("%pn", &a);//打印出的结果就是a在计算机内存中的地址
// printf("%dn", p);
// /
//书--复杂对象
//书名+作者+出版社+定价+书号
//复杂对象 -- 用结构体来描述 -- 结构体：我们自己创造出来的类型
#include
struct Book //struck结构体关键字，用于创建结构体类型。Book为类型名
{
char name[20];//C语言程序设计
short price;//55
}; //这个分号不可缺少，它的作用是结束定义的
int main()
{
//利用结构体类型创建一个该类型的变量
struct Book b1 = {"C语言程序设计", 55};
printf("书名：%s；n", b1.name); //. 结构体变量.成员
printf("价格：%d元；n", b1.price);
b1.price = 15;
printf("甩卖价：%d元；n", b1.price);
return 0;
}
//#include
//#include
//struct Book
//{
// char name[10];
// int price;
//};
//int main()
//{
// struct Book b2 = {"C语言程序设计", 10};
// strcpy(b2.name, "C++");//用于修改字符串中元素的名字。将“C语言程序设计”改为“C++”
// //strcpy -- stringcopy -- 字符串拷贝 -- 库函数 string.h
// b2.price = 5;
// printf("书名：%sn", b2.name);
// printf("价格：%dn", b2.price);
// return 0;
//}
//#include
//struct People
//{
// char name[13];
// char sex[13];
// short years;
//};
//int main()
//{
// struct People p = {"张三", "男", 41};
// struct People* pd = &p;
// printf("姓名：%sn", pd->name);
// printf("性别：%sn", pd->sex);
// printf("年龄：%dn", pd->years);
// return 0;
//}
