1EB=1024PB
1PB=1024TB
1TB=1024GB
1GB=1024MB
1MB=1024KB
1KB=1024B
1Byte=8bit

4G=2^2 * 2^10 * 2^10 * 2^10 =4*1024*1024*1024=2^32

4T=4*1024GB*1024MB*1024KB*1024B*8bit

4T=1000*1000*1000*1000*8

4*1000*1000*1000*1000/1024/1024/1024/1024≈3.63T

1PB=1024TB
1EB=1024PB

1Khz=1000hz
1Mhz=1000khz
1Ghz=1000Mhz

1024=1103+2*101+410^0=1000+20+4=1024

10000000000 =1*2^10=1024

01100101=126+1*25+1*22+1*20=64+32+4+1=101

0127=1*8^2+2*8^1+7=87

0x12f=1*16^2+2*16^1+f*16^0=256+32+15=303

11 001 100 =0314

1100 1110 =0xce

0127=001 010 111

0x12f=0001 0010 1111

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
/*printf格式化输出数据@author liuguanglei ittimelinedotnet@gmail.com@website ittimeline.net@version 2019/08/31
*/
int main(int argc, char* argv[])
{/*声明占据一个字节的变量number,并赋值为-15有符号负数，内存存储的是补码-15的原码是1000 1111-15的反码是1111 0000-15的补码是1111 0001因此内存中存放的是 1111 0001*/char number = -15;/*有符号输出 1111 0001首先看最高位，最高位是1，表示该数是一个负数，需要转换成原码输出补码 1111 0001 转换为原码前首先转换为反码 1000 1110 然后再加1  即1000 1111 按照十进制输出结果就是-15因为最高位是1，表示该数字是负数，因此输出结果是-15*/printf("-15的有符号输出结果是 %d \n",number); //%d按照十进制解析，因此输出结果是-15/*无符号输出时不考虑符号位因为 -15在内存中是使用补码存储，即1111 0001不考虑符号位输出，结果是241，因为1111 0001 转换为二进制的结果是241%u按照无符号整数解析,占据四个字节，但是number只占1个字节但是printf输出时编译器会自动添加24个1， 因此使用按位与去掉编译器自动添加的24个1 number&0x000000ff*/printf("无符号输出-15的结果是%u\n",number&0x000000ff);system("pause");return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
/*十六进制赋值输出@author liuguanglei ittimelinedotnet@gmail.com@website ittimeline.net@version 2019/08/31
*/
int main(int argc, char* argv[])
{/*当给一个变量采用十六进制的值赋值时，内存原样存储，因为十六进制不区分正负0x9b在内存中的存储 1001 1011*/char number = 0x9b;/*有符号获取 0x9b首先将0x9b转换为二进制1001 1011，最高位是1，表示为number的补码这里需要将1001 1011转换为原码首先将1001 1011转换为反码 1001 1011 最高位不变，其他位取反 11100100得到反码后加1，最后的结果是 11100101 一个字节的 1110 0101 最高位是负数 1100101转换为10进制的结果是101因此最终打印输出number =%d 的结果是-101*/printf("16进制0x9b按照有符号输出的结果是  %d \n",number);/*无符号数输出时直接输出1001 1011转换为十进制的输出结果即可 1001 1011转换为十进制的结果是155由于*/printf("16进制0x9b按照无符号输出的结果是  %u \n",number&0x000000ff);// 1001 1011 printf("number = %x \n",number);system("pause");return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
/*常量常量一旦定义后不能被修改(赋值)@author liuguanglei ittimelinedotnet@gmail.com@website ittimeline.net@version  2019/08/28
*/
int main(int argc, char* argv[])
{//日常开发中常用的常量//%c 用于输出一个字符，这里输出字符aprintf("char c= %c \n",'a');//%hd用于输出短整型printf("short s= %hd \n",10);//%d用于输出整型printf("int i= %d \n",100);//%ld用于输出长整型printf("long l= %ld \n",10000);//%lld用于输出长长整型printf("long ll=%lld \n",100000000000000000);//%f用于输出单精度浮点型printf("float f= %f",3.14f);//%ld用于输出双精度浮点型printf("double d= %lf",3.14);//常量一旦定义后不能被修改(赋值)//10 = 20;system("pause");return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
/*const常量@author liuguanglei ittimelinedotnet@gmail.com@website ittimeline.net@version 2019/09/02*/
int main(int argc, char* argv[])
{const int number = 12;//这里会发生编译错误，因为const修饰的变量是常量，常量一旦定义后无法再次被赋值//number = 18;//const虽然无法直接修改，但是可以通过间接的方式依然可以修改const long id = 10001;printf("常量 id的内存地址是%p \n",&id);printf("常量id修改之前的值是%d \n",id);//通过间接的方式修改id的值*(int*)(&id) = 10002;printf("常量id修改之后的值是%d \n", id);system("pause");return 0;
}

#define _CRT_SECURE_NO_WARNINGS
//使用  #define定义常量
#define MY_NAME "Tony"
#define MY_GENDER "Boy"
#include <stdio.h>
#include <stdlib.h>
/*#define常量@author liuguanglei ittimelinedotnet@gmail.com@website ittimeline.net@version 2019/09/02*/
int main(int argc, char* argv[])
{//使用常量printf("my name is %s and my gender is %s \n",MY_NAME,MY_GENDER);system("pause");return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
/*变量的定义@author liuguanglei ittimelinedotnet@gmail.com@website ittimeline.net@version 2019/08/28
*/
int main(int argc, char* argv[])
{//变量定义的语法  变量类型 变量名int number;//变量使用前必须定义并初始化，初始化即定义时给变量赋值，否则会发生编译错误//printf("number = %d",number);//非法的变量名 会造成程序编译错误// 不能以数字开头//int 1number;//只能由字母、数字、下划线组成,这里包含了空格// int num ber;//定义时赋值叫变量的初始化int age = 26;//变量定义int val;//定义完成后再赋值就不叫初始化，只是单纯的赋值val = 12;system("pause");return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
/*变量的声明变量的声明包含显示声明和非显示声明一般情况下都是非显示声明，即变量的定义在使用前面。编译器编译时是从上到下逐语句编译的，当变量的定义在使用前面，编译器能够自动识别变量的声明如果变量的定义在使用的后面，那么此时需要使用extern来显示声明变量，在声明时不用赋值，否则会引发变量“重定义，多次初始化的编译错误@author liuguanglei ittimelinedotnet@gmail.com@website ittimeline.net@version 2019/08/28
*/
//显示声明变量，不用赋值，告诉编译器在使用到该变量的地方编译通过
extern int age;//extern int age=300;  // error C2374:  “age”: 重定义；多次初始化
int main(int argc, char* argv[])
{//编译器从上到下逐行编译，int number=10;//变量的定义在使用之前，此处会自动识别变量的声明printf("number = %d \n",number);printf("age = %d",age);system("pause");return 0;
}
//变量的定义在使用之后
int age = 26;

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
/*变量的操作:读&写打印输出就是读操作赋值操作就是写操作@author liuguanglei ittimelinedotnet@gmail.com@website ittimeline.net@version 2019/08/28*/
int main(int argc, char* argv[])
{//变量赋值 就是变量的写操作int age = 26;//printf函数就是对变量的读操作printf("age = %d\n ",age);//=是将右边的值赋值给左边的变量int my_age = age;//这里也会打印输出my_age = 26printf("my_age = %d\n ", my_age);system("pause");return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
/*变量的操作:算术运算@author liuguanglei ittimelinedotnet@gmail.com@website ittimeline.net@version 2019/08/28*/
int main(int argc, char* argv[])
{int left = 10;int right = 20;int result = left + right;printf("%d + %d = %d \n",left,right, result);result = right - left;printf("%d - %d = %d \n", right, left, result);system("pause");return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
/*变量交换的三种方式@author liuguanglei ittimelinedotnet@gmail.com@website ittimeline.net@version 2019/09/03
*/
int main(int argc, char* argv[])
{int left = 5;int right = 10;printf("使用临时变量实现变量交换交换之前\t left=%d \t right=%d\n", left, right);int middle = left;left = right;right = middle;printf("使用临时变量实现变量交换交换之后\t left=%d \t right=%d\n", left, right);system("pause");return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
/*变量的交换:通过算术运算实现@author liuguanglei ittimelinedotnet@gmail.com@website ittimeline.net@version 2019/09/03
*/
int main(int argc, char* argv[])
{int left = 5;int right = 10;printf("使用算术运算实现变量交换交换之前\t left=%d \t right=%d\n", left, right);left = left + right; // 加号变成乘号right = left - right;//减号变成除号left = left - right; //减号变成除号printf("使用算术运算实现变量交换交换之后\t left=%d \t right=%d\n", left, right);system("pause");return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
/*变量的交换:使用异或运算实现变量交换@author liuguanglei ittimelinedotnet@gmail.com@website ittimeline.net@version 2019/09/03
*/
int main(int argc, char* argv[])
{int left = 5;int right = 10;printf("使用异或运算实现变量交换交换之前\t left=%d \t right=%d\n", left, right);left = left ^ right;right = left ^ right;left = left ^ right;printf("使用异或运算实现变量交换交换之后\t left=%d \t right=%d\n", left, right);system("pause");return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
/*scanf函数获取键盘的输入实现终端不带界面交互@author liuguanglei ittimelinedotnet@gmail.com@website ittimeline.net@version  2019/08/28
*/
int main(int argc, char* argv[])
{//变量初始化时如果类型为整数，推荐初始化为0int age = 0;printf("请输入你的年龄\n(按回车键结束)");//当用户输入数据并回车之后先到达标准输入缓冲区//scanf函数负责从标准缓冲区拿整数，此函数是阻塞的，即等到用户输入数据才会往下执行//%d表示提取键盘输入的数字//变量名仅仅代表变量的内容，如果想要获取变量的起始地址，需要使用&变量名scanf("%d",&age);printf("你的年龄是%d\n",age);system("pause");return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
/*sizeof关键字的使用@author liuguanglei ittimelinedotnet@gmail.com@website ittimeline.net@version 2019/08/28*/
int main(int argc, char* argv[])
{printf("char 占据的字节数量是%d\n",sizeof(char));printf("short 占据的字节数量是%d\n",sizeof(short));printf("int 占据的字节数量是%d\n",sizeof(int));printf("long 占据的字节数量是%d\n",sizeof(long));printf("long long 占据的字节数量是%d\n",sizeof(long long));printf("float 占据的字节数量是%d\n",sizeof(float));printf("double 占据的字节数量是%d\n",sizeof(double));printf("bool 占据的字节数量是%d\n",sizeof(bool));system("pause");return 0;
}

//
// Created by guanglei on 8/28/19.
//
#include <stdio.h>
#include <stdlib.h>
int main(){printf("char 占据的字节数量是%d\n",sizeof(char));printf("short 占据的字节数量是%d\n",sizeof(short));printf("int 占据的字节数量是%d\n",sizeof(int));printf("long 占据的字节数量是%d\n",sizeof(long));printf("long long 占据的字节数量是%d\n",sizeof(long long));printf("float 占据的字节数量是%d\n",sizeof(float));printf("double 占据的字节数量是%d\n",sizeof(double));printf("_Bool 占据的字节数量是%d\n",sizeof(_Bool));return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
/*有符号数(整型，长整型)和无符号数(整型，长整型) 常量@author liuguanglei ittimelinedotnet@gmail.com@website ittimeline.net@version 2019/08/28
*/
int main(int argc, char* argv[])
{//整型常量10默认是有符号的整数,如果想要变成无符号数，需要在10后面加上U，即10Uprintf("%d \n",10);printf("%u \n", 10U);//长整型常量的有符号和无符号//有符号长整型printf("%ld \n",10L);//无符号长整型printf("%lu \n", 10U);system("pause");return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
/*有符号和无符号变量@author liuguanglei ittimelinedotnet@gmail.com@website ittimeline.net@version 2019/08/28
*/
int main(int argc, char* argv[])
{//整数默认就是有符号的,即默认是使用signedsigned int number = 12;printf("number = %d ",number);// 无符号必须加上unsignedunsigned int value = 12;printf("value = %u ", value);system("pause");return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
/*整数常量的三种类型@author liuguanglei ittimelinedotnet@gmail.com@website ittimeline.net@version 2019/09/03
*/
int main(int argc, char* argv[])
{printf("有符号整数常量%d\n",100);printf("无符号整型常量%u\n",100u);printf("有符号长整型常量%ld\n",2147483647L);printf("有符号长长整型常量%lld\n",9223372036854775807LL);system("pause");return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
/*printf输出整数的三个进制表现方式@author liuguanglei ittimelinedotnet@gmail.com@website ittimeline.net@version 2019/08/28
*/
int main(int argc, char* argv[])
{int number = 0;printf("请输入一个整数\n");scanf("%d",&number);//不同进制的输出不会修改number的值，只是数据的表现形式变化了// %o表示按照八进制解析，#表示输出完整进制格式，即以0开头printf("%d按照八进制输出的结果是%#o\n",number,number);printf("%d按照十进制进制输出的结果是%d\n",number, number);// %x表示按照十六进制解析，#表示输出完整进制格式，即以0x开头printf("%d按照十六进制输出的结果是%#x\n",number, number);system("pause");return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
/*整数的极限@author liuguanglei ittimelinedotnet@gmail.com@website ittimeline.net@version 2019/09/03
*/
int int_limits_main(int argc, char* argv[])
{//16位(嵌入式系统) int和short是等价的printf("short能存储的最大值是%d\tshort能存储的最小值是%d,占据的字节数量是%d\n", SHRT_MAX, SHRT_MIN, sizeof(short));printf("unsigned short能存储的最大值是%d\n", USHRT_MAX);//32位和64位系统 int和long是等价的printf("int能存储的最大值是%d\tint能存储的最小值是%d,占据的字节数量是%d\n", INT_MAX, INT_MIN, sizeof(int));printf("unsigned int能存储的最大值是%d\n", UINT_MAX);//无符号的整数 最小值都是0 即不能表示负数printf("long能存储的最大值是%d\tlong能存储的最小值是%d,占据的字节数量是%d\n", LONG_MAX, LONG_MIN, sizeof(long));printf("long long能存储的最大值是%lld\tlong long能存储的最小值是%lld,占据的字节数量是%d\n", LLONG_MAX, LLONG_MIN, sizeof(long long));printf("unsigned long long 能存储的最大值是%llu\n", ULLONG_MAX);system("pause");return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
/*整数的越界@author liuguanglei ittimelinedotnet@gmail.com@website ittimeline.net@version 2019/09/03
*/
int main(int argc, char* argv[])
{//为了保证结果运算正确，必须在极限范围之内unsigned short int  shortnum = 65536;printf("无符号short int所能存储的最大值是%d\n", USHRT_MAX);printf("shortnum=%d", shortnum); //结果为0 因为chnum所能表示的最大值为255,这里发生了越界，结果错误system("pause");return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
/*跨平台的整数@author liuguanglei ittimelinedotnet@gmail.com@website ittimeline.net@version 2019/09/03
*/
int main(int argc, char* argv[])
{long val = 100;printf("windows下long占据的字节数量是%d\n", sizeof(val));//在不同的平台下占据都是32字节int32_t int_32_MAX_VALUE = INT32_MAX;printf("sizeof(int_32_MAX_VALUE ) = %d\n", sizeof(int_32_MAX_VALUE));printf("int_32_MAX_VALUE  = %d\n", int_32_MAX_VALUE);//在不同的平台下占据都是64字节int64_t int_64_MAX_VALUE = INT64_MAX;printf("sizeof(int_64_MAX_VALUE ) = %d\n", sizeof(int_64_MAX_VALUE));printf("int_64_MAX_VALUE  = %lld\n", int_64_MAX_VALUE);system("pause");return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
/*根据给出的边长求面积使用math.h文件中提供的开平方根函数@author liuguanglei ittimelinedotnet@gmail.com@website ittimeline.net@version 2019/09/03
*/
int main(int argc, char* argv[])
{int a = 6;int b = 8;int c = 10;int p = (a + b + c) / 2;//sqrt返回float,这里使用赋值运算完成了类型转换int s = sqrt(p * (p - a) * (p - b) * (p - c));printf("三角形的面积是%d\n", s);system("pause");return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
/*浮点常量@author liuguanglei ittimelinedotnet@gmail.com@website ittimeline.net@version 2019/08/30
*/
int main(int argc, char* argv[])
{//输出结果显示3.14占据8个字节，因为浮点数默认是double类型printf("浮点数3.14占据的字节数量是%d\n",sizeof(3.14));//如果以f结尾的就是float类型printf("浮点数3.14f占据的字节数量是%d\n",sizeof(3.14f));//十进制float flt = 12.0f; //小数后面加f表示float类型double dbl = 12.0; //小数默认是double类型//科学计数法double db1 = 0.12e3;//e之前必须有数字，指数必须为整数double db2 = 12000.124e5; //e5表示10的5次方//%f默认输出小数点后六位printf("flt = %f \n", flt);printf("db1 = %f \t db2 = %f\n", db1, db2);system("pause");return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
/*浮点数变量@author liuguanglei ittimelinedotnet@gmail.com@website ittimeline.net@version 2019/08/30
*/
int main(int argc, char* argv[])
{//在赋值时尽量保证赋值号(=)左右两边类型一致,如果将表示范围大的值赋值给表示范围小的变量，可能会造成数据溢出，float flt = 3.14f;printf("flt = %f \n",flt);flt = 0.0f;printf("flt = %f \n", flt);double dbl = 5.67;//printf()默认输出小数后6位数printf("dbl = %lf \n", dbl);//如果只要输出小数点后2位数，可以使用格式符 %.2lf 实现printf("dbl = %.2lf \n",dbl);//请输入一个浮点数printf("请输入一个浮点数\n");scanf("%lf",&dbl);printf("你输入的浮点数是%.2lf \n",dbl);system("pause");return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <float.h>
/*浮点数占据的内存数量和取值范围在32位和64位Windows上double 和long double是等价的@author liuguanglei ittimelinedotnet@gmail.com@website ittimeline.net@version 2019/09/03
*/
int main(int argc, char* argv[])
{printf("float占据的字节数量是%d\n", sizeof(float));printf("float能存储的最大值是%e\t float能存储的最小值是%e \n", FLT_MAX, FLT_MIN);printf("\n");printf("double占据的字节数量是%d \n ",sizeof(double));printf("double能存储的最大值是%e\t double能存储的最小值是%e \n", DBL_MAX, DBL_MIN);printf("\n");printf("long double占据的字节数量是%d\n", sizeof(long double));printf("long double 能存储的最大值是%e\t long ouble能存储的最小值是%e \n", LDBL_MAX, LDBL_MIN);system("pause");return 0;
}

四字节浮点数  最左边的第一位是最高位0000 0000 0000 0000 0000 0000 0000 0000

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
/*浮点数的相等性判断如果实数超过有效范围，使用==判断会出错@author liuguanglei ittimelinedotnet@gmail.com@website ittimeline.net@version 2019/09/03
*/
int main(int argc, char* argv[])
{float flt1 = 1.00000000001;float flt2 = 1.00000000000000000001;//因为float的有效数字是6-7位 这里超出有效数字 计算不准确printf(" flt1 == flt2 ? %d\n", (flt1 == flt2)); // 输出结果1表示相等 0则表示不相等//double精确的有效位数是15-16位，这里也超出了有效数字，计算不够正确 double db1 = 1.00000000000000000000000000000001;double db2 = 1.000000000000000000000000000000000000000000000000000000000000000000000000000000001;printf(" db1 == db2 ? %d\n", (db1 == db2)); // 输出结果1表示相等 0则表示不相等system("pause");return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
/*给出当前中国、美国的GDP以及增长率，计算中国超过美国的年份@author liuguanglei ittimelinedotnet@gmail.com@website ittimeline.net@version 2019/09/03
*/
int main(int argc, char* argv[])
{//当前中美GDPdouble ch_current_gdp = 14.6;double us_current_gdp = 20.5;//当前中美GDP的增长率double ch_rate = 1.06;double us_rate = 1.04;double ch_gdp=0.0;double us_gdp=0.0;int year=2018;for (int i = 1; i <= 100; i++) {//使用pow函数计算中美每年增长后的GDPch_gdp = ch_current_gdp * pow(ch_rate, i);us_gdp = us_current_gdp * pow(us_rate, i);year++;printf("%d年中国的GDP是%f\n", year, ch_gdp);printf("%d年美国的GDP是%f\n", year, us_gdp);if (ch_gdp > us_gdp) {printf("在%d年，中国的GDP超越了美国的GDP", year);break;}}system("pause");return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
/*字符常量(英文)@author liuguanglei ittimelinedotnet@gmail.com@website ittimeline.net@version  2019/08/30
*/
int main(int argc, char* argv[])
{//输出英文字符printf("输出英文字符%c\n",'a');printf("char占据的字节数量是%d\n",sizeof(char));system("pause");return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include <locale.h> //引入本地化的头文件
#include <stdio.h>
#include <stdlib.h>
/*中文字符@author liuguanglei ittimelinedotnet@gmail.com@website ittimeline.net@version 2019/08/30
*/
int main(int argc, char* argv[])
{//设置本地化setlocale(LC_ALL, "chs");wchar_t ch = L'刘';//使用wprintf()函数输出中文wprintf(L"ch = %c \n",ch);system("pause");return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
/*输出字符的两种方式@author liuguanglei ittimelinedotnet@gmail.com@website ittimeline.net@version 2019/09/03
*/
int main(int argc, char* argv[])
{char c = 'A';putchar(c);printf("\n");printf("c = %c \n",c);system("pause");return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
/*字符变量字符变量的本质存储的是字符的ASC||码值@author liuguanglei ittimelinedotnet@gmail.com@website ittimeline.net@version 2019/08/30
*/
int main(int argc, char* argv[])
{//声明并初始化字符变量ch，初始化值为zchar ch = 'z';printf("char ch = %c \n", ch);printf("字符变量%c对应的整数是%d \n",ch,ch);printf("char占据的字节大小是 %u \n",sizeof(ch));system("pause");return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
/*常用的字符对应的ASC||表输出字符使用%c,输出ASC||值使用%d@author liuguanglei ittimelinedotnet@gmail.com@website ittimeline.net@version 2019/08/30
*/
int main(int argc, char* argv[])
{char ch = '0';printf("字符%c对应的整数是%d\n", ch, ch);ch = 'a';printf("字符%c对应的整数是%d\n", ch, ch);ch = 'A';printf("字符%c对应的整数是%d\n", ch, ch);int number = 97;printf("数字%d对应的字符是%c\n", number, number);number = 65;printf("数字%d对应的字符是%c\n", number, number);number = 48;printf("数字%d对应的字符是%c\n", number, number);system("pause");return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
/*字符的大小写转换@author liuguanglei ittimelinedotnet@gmail.com@website ittimeline.net@version 2019/08/30
*/
int main(int argc, char* argv[])
{//小写转大写 char lower_ch = 'a';// 0x20就是十进制的32char upper_ch = lower_ch - 0x20;printf("小写字母%c转换为大写字母的结果是%c \n",lower_ch,upper_ch);//大写转小写upper_ch = 'A';lower_ch = upper_ch + 32;printf("大写字母%c转换为小写字母的结果是%c \n", upper_ch, lower_ch);system("pause");return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
/*转义字符@author liuguanglei ittimelinedotnet@gmail.com@website ittimeline.net@version 2019/08/30
*/
int main(int argc, char* argv[])
{//声音无法输出在屏幕上显示，因此这里使用转字符\a实现发声printf("%c",'\a');//日常开发中常用的转移字符 \n实现换行printf("hello \n");printf("world \n");// \t 实现tab效果printf("C\t语\t言\t核\t心\t编\t程\n");// \r 实现光标移到行首 由于光标移到行首，最终只会输出C语言核心编程printf("CPrimerPlus%cC语言核心编程\n",'\r');//路径转义 \\表示路径转义 //使用system函数使用电脑上的微信，调用成功的前提条件是电脑上安装了微信system("\"C:\\Program Files (x86)\\Tencent\\WeChat\\WeChat.exe\"");// %%实现输出百分号printf("合格率为%%%d\n",90);//八进制转义和十六进制转义//八进制的62转换为十进制是50，50表示字符2char ch = '\62';printf("八进制的转义字符62转换为字符的结果是%c \n",ch);//2//十六进制的62转换为十进制是98，98表示的字符是bch = '\x62';printf("十六进制的转义字符62转换为字符的结果是%c\n", ch); //bsystem("pause");return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
/*C语言字符串以\0结尾空字符串也会占据一个字节中文占据两个字节@author liuguanglei ittimelinedotnet@gmail.com@website ittimeline.net@version 2019/09/03
*/
int main(int argc, char* argv[])
{//字符串是以/0结尾，这里字符串A占据2个字节printf("字符串A占据的字节数量是%d\n", sizeof("A"));//空字符串也是以\0结尾，因此这里占据一个字节printf("\"\"占据的字节数量为%d\n", sizeof("")); //以\0结尾//字符串单个中文占据两个字节printf("字符串刘光磊占据的字节数量是%d\n", sizeof("刘光磊")); //每个中文占据两个字节，然后以\0结尾 因此是7个system("pause");return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
/*字符串加密解密简单实现@author liuguanglei ittimelinedotnet@gmail.com@website ittimeline.net@version 2019/09/03
*/
int main(int argc, char* argv[])
{//使用字符数组初始化一个字符串 calcchar str[5] = { 'c','a','l','c','\0' };//调用计算器system(str);printf("加密之前str = %s\n", str);//循环 将字符+1 因为字符的本质就是ASC||码 因此可以当作整数来使用for (int i = 0; i < 4; i++) {str[i] += 1;}printf("加密之后str = %s\n", str);//逆运算解密for (int i = 0; i < 4; i++) {str[i] -= 1;}printf("解密之后str = %s\n", str);system("pause");return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
/*bool类型的使用@author liuguanglei ittimelinedotnet@gmail.com@website ittimeline.net@version 2019/09/03
*/
int main(int argc, char* argv[])
{bool flag = true;//占据的字节数量为1printf("bool占据的字节数量是%d\n", sizeof(flag));//成立的结果为1printf("bool = %d\n", flag);flag = false;//不成立的结果为0printf("bool = %d\n", flag);//bool在if/else结构和关系运算的使用int age = 20;bool isAdult = age > 18;if (isAdult==1) {printf("你成年了\n");}else {printf("你没有成年\n");}system("pause");return 0;
}