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 用于输出一个字符，这里输出字符a
    printf("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 = 26
    printf("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[])
{

    //变量初始化时如果类型为整数，推荐初始化为0
    int 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，即10U
    printf("%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[])
{

    //整数默认就是有符号的,即默认是使用signed
    signed int number = 12;
    printf("number = %d ",number);

    // 无符号必须加上unsigned
    unsigned 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[])
{
    //当前中美GDP
    double 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函数计算中美每年增长后的GDP
        ch_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，初始化值为z
    char 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就是十进制的32
    char 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表示字符2
    char ch = ‘\62‘;
    printf("八进制的转义字符62转换为字符的结果是%c \n",ch);//2
    //十六进制的62转换为十进制是98，98表示的字符是b
    ch = ‘\x62‘;
    printf("十六进制的转义字符62转换为字符的结果是%c\n", ch); //b

    system("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[])
{

    //使用字符数组初始化一个字符串 calc
    char 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;
    //占据的字节数量为1
    printf("bool占据的字节数量是%d\n", sizeof(flag));
    //成立的结果为1
    printf("bool = %d\n", flag);

    flag = false;
    //不成立的结果为0
    printf("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;
}