我的全栈之路-C语言基础之数据存储

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=1*10^3+2*10^1+4*10^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 
",number); //%d按照十进制解析，因此输出结果是-15


    /*
      无符号输出时不考虑符号位
      因为 -15在内存中是使用补码存储，即1111 0001
      不考虑符号位输出，结果是241，因为1111 0001 转换为二进制的结果是241
      %u按照无符号整数解析,占据四个字节，但是number只占1个字节
      但是printf输出时编译器会自动添加24个1， 因此使用按位与去掉编译器自动添加的24个1 number&0x000000ff
    */

    printf("无符号输出-15的结果是%u
",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 
",number);


    /*
        无符号数输出时直接输出1001 1011转换为十进制的输出结果即可 1001 1011转换为十进制的结果是155
        由于
    */

    printf("16进制0x9b按照无符号输出的结果是  %u 
",number&0x000000ff);
    // 1001 1011 
    printf("number = %x 
",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 
",'a');
    //%hd用于输出短整型
    printf("short s= %hd 
",10);
    //%d用于输出整型
    printf("int i= %d 
",100);
    //%ld用于输出长整型
    printf("long l= %ld 
",10000);
    //%lld用于输出长长整型
    printf("long ll=%lld 
",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/08/28

*/
int main(int argc, char* argv[])
{
    const int number = 12;
    //这里会发生编译错误，因为const修饰的变量是常量，常量一旦定义后无法再次被赋值
    //number = 18;

    //const虽然无法直接修改，但是可以通过间接的方式依然可以修改
    const long id = 10001;
    printf("常量 id的内存地址是%p 
", &id);

    printf("常量id修改之前的值是%d 
", id);

    //通过间接的方式修改id的值
    //(int*) 类型转换为非 常量地址
    //* 根据地址取出内容
    *(int*)(&id) = 10002;
    printf("常量id修改之后的值是%d 
", 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/08/28

*/
int main(int argc, char* argv[])
{
    //使用常量
    printf("my name is %s and my gender is %s 
",MY_NAME,MY_GENDER);
    system("pause");
    return 0;
}

/*
    使用define实现代码混淆
    @author liuguanglei ittimelinedotnet@gmail.com
    @website ittimeline.net
    @version  2019/08/28
*/
#include <stdio.h>
#include <stdlib.h>
#define _ void
#define __ main()
#define ___ {
#define ____ system("notepad");
#define _____ system("pause");
#define ______ }

#include "define.h"

/*
    使用define实现代码混淆
    @author liuguanglei ittimelinedotnet@gmail.com
    @website ittimeline.net
    @version  2019/08/28
*/
_ __ ___ ____ _____ ______

#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 num = 20;
    //查看num的内存地址
    printf("整数变量num的地址是%p
", &num);
    printf("整数变量num = %d
", num);
    num = 30;
    printf("修改之后整数变量num的值是%d
", num);
    system("pause");
    return 0;

}

#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;
    //见名知意
    int age;
    char ch;
    double db;
    //变量名不能是关键字
    //int void;
    //变量名不能以数字开头
    //int 1num;
    /****************************************编译器特性*******************************/
    //VC支持中文变量,GCC不支持中文命名
    int 年龄 = 29;
    printf("年龄 =%d
", 年龄);
    //在老版(C++11之前)的编译器中，变量声明必须放在函数调用之前
    /****************************************编译器特性*******************************/
    //声明多个变量
    int one, two, three;
    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 
",number);

    printf("age = %d",age);
    system("pause");
    return 0;
}
//变量的定义在使用之后
int age = 26;

#include <stdio.h>
#include <stdlib.h>
/*
    
    变量在使用前必须初始化赋值，否则会出现C4700错误-> "使用了未初始化的局部变量"
    @author liuguanglei ittimelinedotnet@gmail.com
    @website ittimeline.net
    @version 2019/08/28
*/
int main() {
    //声明一个整数变量并未初始化
    int num;
    //编译错误错误	C4700	使用了未初始化的局部变量“num”
    printf("num =%d
", num);
    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[])
{

    //变量初始化时如果类型为整数，推荐初始化为0
    int number = 0;
    double dbl = 0.0;
    char c = 'u00';
    

    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 age = 26;
    //printf函数就是对变量的读操作
    printf("age = %d
 ",age);
    //=是将右边的值赋值给左边的变量
    int my_age = age;
    //这里也会打印输出my_age = 26
    printf("my_age = %d
 ", 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 
",left,right, result);
    result = right - left;
    printf("%d - %d = %d 
", right, left, result);
    system("pause");
    return 0;
}

#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 a = 1;
    int b = 2;
    //分配四个字节的内存
    int c;
    printf("变量a的地址是%p	，变量b的地址是%p	，变量c的地址是%p
", &a, &b, &c);
    //数据的运算是在CPU的寄存器完成的
    c = a + b;
    c = b - a;
    //对数据的操作是由CPU完成的,因此这里不能直接复制
    //a + 1 = 4;
    printf("c=%d
", c);
    system("pause");

    return 0;

}

#include <stdio.h>
#include <stdlib.h>
/*
    使用汇编语言实现变量的赋值以及运算来理解数据的运算是在CPU内部的寄存器完成的
    @author liuguanglei ittimelinedotnet@gmail.com
    @website ittimeline.net
    @version 2019/08/28

*/
int main() {

    //申请四个字节的内存
    int a;
    printf("整数变量a的地址是%p
", &a);


    //变量的赋值都是通过CPU的寄存器来完成的
    //这里借助汇编语言实现将10赋值给变量a
    _asm {

        mov eax, 10
        mov a, eax
    }

    printf("整数变量a的值等于%d
", a);

    _asm {

        //把变量a的值赋值给寄存器eax
        mov eax, a
        //将eax的值加5
        add eax, 5
        //把eax的值赋值给a
        mov a, eax
    }
    printf("变量a加5之后的结果是%d
", a);
    system("pause");

    return 0;
}

#include <stdio.h>
#include <stdlib.h>

/*
    编译器和内存对变量的处理
    @author liuguanglei ittimelinedotnet@gmail.com
    @website ittimeline.net
    @version 2019/08/28
*/
int main(int argc, char* argv[]) {

    //声明3个整数变量
    int a, b, c;
    //这里会发生编译错误 不能使用未声明的变量
    //printf(" %d
", d);
    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("使用临时变量实现变量交换交换之前	 left=%d 	 right=%d
", left, right);
    int middle = left;
    left = right;
    right = middle;
    printf("使用临时变量实现变量交换交换之后	 left=%d 	 right=%d
", 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("使用算术运算实现变量交换交换之前	 left=%d 	 right=%d
", left, right);
    left = left + right; // 加号变成乘号
    right = left - right;//减号变成除号
    left = left - right; //减号变成除号
    printf("使用算术运算实现变量交换交换之后	 left=%d 	 right=%d
", 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("使用异或运算实现变量交换交换之前	 left=%d 	 right=%d
", left, right);
    left = left ^ right;
    right = left ^ right;
    left = left ^ right;
    printf("使用异或运算实现变量交换交换之后	 left=%d 	 right=%d
", 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("请输入你的年龄
(按回车键结束)");
    //当用户输入数据并回车之后先到达标准输入缓冲区
    //scanf函数负责从标准缓冲区拿整数，此函数是阻塞的，即等到用户输入数据才会往下执行
    //%d表示提取键盘输入的数字
    //变量名仅仅代表变量的内容，如果想要获取变量的起始地址，需要使用&变量名
    scanf("%d",&age);

    printf("你的年龄是%d
",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
",sizeof(char));
    printf("short 占据的字节数量是%d
",sizeof(short));
    printf("int 占据的字节数量是%d
",sizeof(int));
    printf("long 占据的字节数量是%d
",sizeof(long));
    printf("long long 占据的字节数量是%d
",sizeof(long long));
    printf("float 占据的字节数量是%d
",sizeof(float));
    printf("double 占据的字节数量是%d
",sizeof(double));
    printf("bool 占据的字节数量是%d
",sizeof(bool));
    system("pause");
    return 0;
}

//
// Created by guanglei on 8/28/19.
//
#include <stdio.h>
#include <stdlib.h>
int main(){

    printf("char 占据的字节数量是%d
",sizeof(char));
    printf("short 占据的字节数量是%d
",sizeof(short));
    printf("int 占据的字节数量是%d
",sizeof(int));
    printf("long 占据的字节数量是%d
",sizeof(long));
    printf("long long 占据的字节数量是%d
",sizeof(long long));
    printf("float 占据的字节数量是%d
",sizeof(float));
    printf("double 占据的字节数量是%d
",sizeof(double));
    printf("_Bool 占据的字节数量是%d
",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 
",10);
    printf("%u 
", 10U);

    //长整型常量的有符号和无符号

    //有符号长整型
    printf("%ld 
",10L);
    //无符号长整型
    printf("%lu 
", 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>
#include <limits.h>
#include <float.h>

/*
    数据类型的极限
    @author liuguanglei ittimelinedotnet@gmail.com
    @website ittimeline.net
    @version 2019/08/28

*/
int main(int argc, char* argv[]) {
    printf("int能存储的最大值是%d	int能存储的最小值是%d,占据的字节数量是%d
", INT_MAX, INT_MIN, sizeof(int));
    printf("double能存储的最大值是%e	 double能存储的最小值是%e,double占据的字节数量是%d
 
", DBL_MAX, DBL_MIN,sizeof(double));

    printf("unsigned char 表示的最大值是%d
",UCHAR_MAX);
    //无符号的char存储的最大值是255 这里超过了最大范围，输出的结果不是预期的256，,而且0
    unsigned char num = 255+1;
    printf("num = %d
",num);

    system("pause");

    return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
/*
    printf处理数据类型
    @author liuguanglei ittimelinedotnet@gmail.com
    @website ittimeline.net
    @version 2019/08/28

*/
int main(int argc, char* argv[]){

    int number = 10;
    
    printf("number = %f 
",number);
    printf("number = %f 
", (float)number);


    float flt = 10.8;
    //printf不会进行数据类型转换
    printf("flt = %d 
",flt);
    //使用强制类型转换实现输出正确的结果
    printf("flt = %d 
", (int)flt);


    return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
/*
    数据在内存中的存储
    @author liuguanglei ittimelinedotnet@gmail.com
    @website ittimeline.net
    @version 2019/08/28

*/
int main(int argc, char* argv[]) {

    int number = 10;
    printf("number的内存地址是%p
", &number);
    printf("number = %d",number);


    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
",100);
    printf("无符号整型常量%u
",100u);
    printf("有符号长整型常量%ld
",2147483647L);
    printf("有符号长长整型常量%lld
",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("请输入一个整数
");
    scanf("%d",&number);
    //不同进制的输出不会修改number的值，只是数据的表现形式变化了
    // %o表示按照八进制解析，#表示输出完整进制格式，即以0开头
    printf("%d按照八进制输出的结果是%#o
",number,number);
    printf("%d按照十进制进制输出的结果是%d
",number, number);
    // %x表示按照十六进制解析，#表示输出完整进制格式，即以0x开头
    printf("%d按照十六进制输出的结果是%#x
",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/08/28
*/
int int_limits_main(int argc, char* argv[])
{
    //16位(嵌入式系统) int和short是等价的
    printf("short能存储的最大值是%d	short能存储的最小值是%d,占据的字节数量是%d
", SHRT_MAX, SHRT_MIN, sizeof(short));
    printf("unsigned short能存储的最大值是%d
", USHRT_MAX);
    //32位和64位系统 int和long是等价的
    printf("int能存储的最大值是%d	int能存储的最小值是%d,占据的字节数量是%d
", INT_MAX, INT_MIN, sizeof(int));
    printf("unsigned int能存储的最大值是%d
", UINT_MAX);
    //无符号的整数 最小值都是0 即不能表示负数
    printf("long能存储的最大值是%d	long能存储的最小值是%d,占据的字节数量是%d
", LONG_MAX, LONG_MIN, sizeof(long));
    printf("long long能存储的最大值是%lld	long long能存储的最小值是%lld,占据的字节数量是%d
", LLONG_MAX, LLONG_MIN, sizeof(long long));
    printf("unsigned long long 能存储的最大值是%llu
", 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/08/28
*/
int main(int argc, char* argv[])
{
    //为了保证结果运算正确，必须在极限范围之内
    unsigned short int  shortnum = 65536;
    printf("无符号short int所能存储的最大值是%d
", USHRT_MAX);
    printf("shortnum=%d", shortnum); //结果为0 因为chnum所能表示的最大值为65535,这里发生了越界，结果错误
    system("pause");
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
/*
    long long 的应用场景
    @author liuguanglei ittimelinedotnet@gmail.com
    @website ittimeline.net
    @version 2019/08/28
*/
int main() {

    unsigned long long mobilePhone = 18601767221;
    printf("mobilePhone=%llu
", mobilePhone);
    unsigned long long qq = 1079351401;
    printf(" qq  = %llu", qq);
    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/08/28
*/
int main(int argc, char* argv[])
{
    long val = 100;
    printf("windows下long占据的字节数量是%d
", sizeof(val));

    //在不同的平台下占据都是32字节
    int32_t int_32_MAX_VALUE = INT32_MAX;
    printf("sizeof(int_32_MAX_VALUE ) = %d
", sizeof(int_32_MAX_VALUE));
    printf("int_32_MAX_VALUE  = %d
", int_32_MAX_VALUE);


    //在不同的平台下占据都是64字节
    int64_t int_64_MAX_VALUE = INT64_MAX;
    printf("sizeof(int_64_MAX_VALUE ) = %d
", sizeof(int_64_MAX_VALUE));
    printf("int_64_MAX_VALUE  = %lld
", 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/08/28
*/
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
", 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/28
*/
int main(int argc, char* argv[])
{
    //输出结果显示3.14占据8个字节，因为浮点数默认是double类型
    printf("浮点数3.14占据的字节数量是%d
",sizeof(3.14));
    //如果以f结尾的就是float类型
    printf("浮点数3.14f占据的字节数量是%d
",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 
", flt);
    printf("db1 = %f 	 db2 = %f
", 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/28
*/
int main(int argc, char* argv[])
{
    //在赋值时尽量保证赋值号(=)左右两边类型一致,如果将表示范围大的值赋值给表示范围小的变量，可能会造成数据溢出，
    float flt = 3.14f;
    printf("flt = %f 
",flt);
    flt = 0.0f;
    printf("flt = %f 
", flt);

    double dbl = 5.67;
    //printf()默认输出小数后6位数
    printf("dbl = %lf 
", dbl);
    //如果只要输出小数点后2位数，可以使用格式符 %.2lf 实现
    printf("dbl = %.2lf 
",dbl);

    //请输入一个浮点数
    printf("请输入一个浮点数
");
    scanf("%lf",&dbl);
    printf("你输入的浮点数是%.2lf 
",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/08/28
*/
int main(int argc, char* argv[])
{
    printf("float占据的字节数量是%d
", sizeof(float));
    printf("float能存储的最大值是%e	 float能存储的最小值是%e 
", FLT_MAX, FLT_MIN);
    printf("
");
    printf("double占据的字节数量是%d 
 ",sizeof(double));
    printf("double能存储的最大值是%e	 double能存储的最小值是%e 
", DBL_MAX, DBL_MIN);
    printf("
");
    printf("long double占据的字节数量是%d
", sizeof(long double));
    printf("long double 能存储的最大值是%e	 long ouble能存储的最小值是%e 
", 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/08/28
*/
int main(int argc, char* argv[])
{
    float flt1 = 1.00000000001;
    float flt2 = 1.00000000000000000001;
    //因为float的有效数字是6-7位 这里超出有效数字 计算不准确
    printf(" flt1 == flt2 ? %d
", (flt1 == flt2)); // 输出结果1表示相等 0则表示不相等

    //double精确的有效位数是15-16位，这里也超出了有效数字，计算不够正确 
    double db1 = 1.00000000000000000000000000000001;
    double db2 = 1.000000000000000000000000000000000000000000000000000000000000000000000000000000001;

    printf(" db1 == db2 ? %d
", (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/08/28
*/
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
", year, ch_gdp);
        printf("%d年美国的GDP是%f
", 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/28
*/
int main(int argc, char* argv[])
{
    //输出英文字符
    printf("输出英文字符%c
",'a');
    printf("char占据的字节数量是%d
",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/28
*/
int main(int argc, char* argv[])
{


    //设置本地化
    setlocale(LC_ALL, "chs");
    wchar_t ch = L'刘';
    //使用wprintf()函数输出中文
    wprintf(L"ch = %c 
",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/28
*/
int main(int argc, char* argv[])
{
    char c = 'A';
    putchar(c);
    printf("
");
    printf("c = %c 
",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/28
*/
int main(int argc, char* argv[])
{

    //声明并初始化字符变量ch，初始化值为z
    char ch = 'z';
    printf("char ch = %c 
", ch);
    printf("字符变量%c对应的整数是%d 
",ch,ch);
    printf("char占据的字节大小是 %u 
",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/28
*/
int main(int argc, char* argv[])
{
    char ch = '0';
    printf("字符%c对应的整数是%d
", ch, ch);
    ch = 'a';
    printf("字符%c对应的整数是%d
", ch, ch);
    ch = 'A';
    printf("字符%c对应的整数是%d
", ch, ch);

    int number = 97;
    printf("数字%d对应的字符是%c
", number, number);
    number = 65;
    printf("数字%d对应的字符是%c
", number, number);
    number = 48;
    printf("数字%d对应的字符是%c
", 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/28
*/
int main(int argc, char* argv[])
{

    
    //小写转大写 
    char lower_ch = 'a';
    // 0x20就是十进制的32
    char upper_ch = lower_ch - 0x20;

    printf("小写字母%c转换为大写字母的结果是%c 
",lower_ch,upper_ch);


    //大写转小写
    upper_ch = 'A';
    lower_ch = upper_ch + 32;
    printf("大写字母%c转换为小写字母的结果是%c 
", 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/28
*/
int main(int argc, char* argv[])
{

    //声音无法输出在屏幕上显示，因此这里使用转字符a实现发声
    printf("%c",'a');
    //日常开发中常用的转移字符 
实现换行
    printf("hello 
");
    printf("world 
");
    // 	 实现tab效果
    printf("C	语	言	核	心	编	程
");
    // 
 实现光标移到行首 由于光标移到行首，最终只会输出C语言核心编程
    printf("CPrimerPlus%cC语言核心编程
",'
');
    //路径转义 \表示路径转义 
    //使用system函数使用电脑上的微信，调用成功的前提条件是电脑上安装了微信
    system(""C:\Program Files (x86)\Tencent\WeChat\WeChat.exe"");
    // %%实现输出百分号
    printf("合格率为%%%d
",90);

    //八进制转义和十六进制转义
    //八进制的62转换为十进制是50，50表示字符2
    char ch = '62';
    printf("八进制的转义字符62转换为字符的结果是%c 
",ch);//2
    //十六进制的62转换为十进制是98，98表示的字符是b
    ch = 'x62';
    printf("十六进制的转义字符62转换为字符的结果是%c
", ch); //b

    system("pause");
    return 0;
}