1YB=1024ZB
1ZB=1024EB
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

0b10000000000 =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

0.11001=1*2^-1+1*2^-2+1*2^-5=0.5+0.25+1/32=0.75+0.03125=0.78125=25/32

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
/*
	sizeof运算符
	@author liuguanglei ittimelinedotnet@gmail.com
	@wechat 18601767221
	@website ittimeline.net
	@version 2019/12/18
*/
int main(int argc, char* argv[])
{
	//使用printf函数输出各个基本数据类型占据的字节数量
	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 <float.h>
#include <stdbool.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("long double 占据的字节数量是%d\n",sizeof(long double));
    printf("bool 占据的字节数量是%d\n",sizeof(bool));

    return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#include <float.h>
/*

	数据类型的极限
		数据类型都有其存储范围(即存储的最大值和最小值)，C语言中的limits.h和float.h头文件中分别定义了整数和浮点数的极限。在使用数据类型时，切勿超过其极限，否则会造成程序异常。

	@author liuguanglei ittimelinedotnet@gmail.com
	@wechat 18601767221
	@website ittimeline.net
    @version 2019/12/17

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

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

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
/*

    printf输出常用基本数据类型的常量
	@author liuguanglei ittimelinedotnet@gmail.com
	@wechat 18601767221
	@website ittimeline.net
	@version 2019/12/17
*/
int main(int argc, char* argv[])
{
	//%c 用于输出一个字符，这里输出字符a 因此完整的输出内容为char 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用于输出单精度浮点型 3.14后的f表示将3.14当成单精度浮点数处理
	printf("float f = %f", 3.14f);
	//%ld用于输出双精度浮点型
	printf("double d = %lf", 3.14);
	system("pause");
	return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#define data 10
/*
	使用#define常量
	@author liuguanglei ittimelinedotnet@gmail.com
	@wechat 18601767221
	@website ittimeline.net
	@version 2020/01/02
*/
void use_data() {
	//使用#define定义的常量可以在多个方法中使用
	printf("use_data() data = %d \n",data);
}

int main(int argc, char* argv[])
{	
	//使用#define定义的常量可以在多个方法中使用
	use_data();
	printf("main() data = %d \n", data);

	system("pause");
	return 0;
}

#pragma once
#define _ int
#define __ main
#define ___ ()
#define ____ {
#define _____  printf("Windows10 1903 & Visual Studio 2019 Hello World With C \n");
#define ______ system("pause");
#define _______ return 0;
#define ________ }

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include "define_code.h"
/*
	define常量
	使用define实现代码混淆
	@author liuguanglei ittimelinedotnet@gmail.com
	@wechat 18601767221
	@website ittimeline.net
	@version 2020/01/02
*/
_ __ ___ ____ _____ ______ _______ ________

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
/*

	变量在内存中的存储以及读写操作的本质

	@author liuguanglei ittimelinedotnet@gmail.com
	@wechat 18601767221
	@website ittimeline.net
	@version 2019/12/17
*/
int main(int argc, char* argv[])
{
	int num = 20;
	//查看num的内存地址
	printf("整数变量num的地址是%p\n", &num);
	printf("整数变量num = %d\n", num);
	num = 30;
	printf("修改之后整数变量num的值是%d\n", num);
	system("pause");
	system("pause");
	return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
/*
	变量的命名规范
	@author liuguanglei ittimelinedotnet@gmail.com
	@wechat 18601767221
	@website ittimeline.net
	@version 2019/12/18
*/
int main(int argc, char* argv[])
{
	// 合法的标识符
	int number;
	//见名知意
	int age;
	char ch;
	double db;
	//变量名不能是关键字
	//int void;
	//变量名不能以数字开头
	//int 1num;
	/****************************************编译器特性*******************************/
	//VC支持中文变量,GCC不支持中文命名
	int 年龄 = 29;
	printf("年龄 =%d\n", 年龄);
	//在老版(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
	@wechat 18601767221
	@website ittimeline.net
	@version 2019/12/18
*/
int main(int argc, char* argv[])
{
	//变量定义的语法  变量类型 变量名
	int number;
	//变量使用前必须定义并初始化，初始化即定义时给变量赋值，否则会发生编译错误
	//printf("number = %d",number);


	 //定义时赋值叫变量的初始化
	int age = 26;

	//变量定义
	int val;
	//定义完成后再赋值就不叫初始化，只是单纯的赋值
	val = 12;
	system("pause");
	return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
/*

	基本数据类型变量的初始化
	@author liuguanglei ittimelinedotnet@gmail.com
	@wechat 18601767221
	@website ittimeline.net
	@version 2019/12/18

*/
int main(int argc, char* argv[])
{
	//变量初始化时如果类型为整数，推荐初始化为0
	int number = 0;
	double dbl = 0.0;
	//字符型推荐初始化为\u00
	char c = ‘\u00‘;

	printf("c=%c\n",c);

	system("pause");
	return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
/*

    变量使用的注意事项
	变量在使用前必须初始化赋值，否则会出现C4700错误-> "使用了未初始化的局部变量"
	@author liuguanglei ittimelinedotnet@gmail.com
	@wechat 18601767221
	@website ittimeline.net
	@version 2019/12/18
*/
int main(int argc, char* argv[])
{
	//声明一个整数变量并未初始化
	int num;
	//编译错误错误	C4700	使用了未初始化的局部变量“num”
	printf("num =%d\n", num);
	system("pause");
	return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
/*

    声明变量-自动识别
	@author liuguanglei ittimelinedotnet@gmail.com
	@wechat 18601767221
	@website ittimeline.net
	@version 2019/12/18
*/
int main(int argc, char* argv[])
{
	//编译器从上到下逐行编译，
	int number = 10; // 变量的定义
	//变量的定义在使用之前，此处会自动识别变量的声明
	printf("number = %d \n", number);//变量的使用
	system("pause");
	return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
/*
    声明变量-显示化声明变量
	@author liuguanglei ittimelinedotnet@gmail.com
	@wechat 18601767221
	@website ittimeline.net
	@version 2019/12/18
*/

extern int age;

int main(int argc, char* argv[])
{
	printf("age = %d \n", age);
	system("pause");
	return 0;
}
//变量的定义在使用之后
int age = 26;

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
/*

	变量的读写操作
	打印输出就是读操作
	赋值操作就是写操作
	@author liuguanglei ittimelinedotnet@gmail.com
	@wechat 18601767221
	@website ittimeline.net
	@version 2019/12/18
*/
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
	@wechat 18601767221
	@website ittimeline.net
	@version 2019/12/18
*/
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;
}

/*
	打印输出两个整数参数的值
*/
void println(int left, int right) {
	printf("left = %d right = %d\n", left, right);
}

/*
	使用中间变量实现变量交换
	时空复杂度分析
	缺点:需要开辟新的内存空间
	优点:完成一次变量交换只需要执行三次赋值运算
*/
void swap_with_temp() {
	int left = 10;
	int right = 20;
	printf("通过中间变量实现变量交换变量交换之前:");
	println(left, right);

	int temp = left; // left=10 temp=10
	left = right; //right=20 left=20
	right = temp;// temp=10 right=10
	printf("通过中间变量实现变量交换变量交换之后:");
	println(left,right);
}

/*
	使用算术运算实现变量交换
	时空复杂度分析
	优点:不需要引入中间变量，节省内存。算术运算还需要考虑数据越界的情况
	缺点:需要通过三次算术运算和三次赋值运算实现变量交换，相比使用中间变量而言计算次数多。
*/
void swap_with_arithmetic() {
	int left = 10;
	int right = 20;
	printf("通过算术运算实现变量交换之前:");
	println(left,right);
	left = left + right; // left=30 right=20
	right = left - right;// right=10 left=30
	left = left - right;// left=20 right=10

	printf("通过算术运算实现变量交换之后:");
	println(left, right);
}

/*
	使用异或运算实现变量交换
	时空复杂度分析
	优点:不需要考虑算术运算的数据越界问题，也没有使用中间变量
	缺点:需要使用三次异或运算和三次赋值运算
*/
void swap_with_xor() {
	int left = 10;
	int right = 20;
	printf("通过异或运算实现变量交换之前:");
	println(left, right);
	left = left ^ right; // left=30 right=20
	right = left ^ right;// right=10 left=30
	left = left ^ right;// left=20 right=10

	printf("通过异或运算实现变量交换之后:");
	println(left, right);
}

/*
	变量交换的时空复杂度分析
	@author liuguanglei ittimelinedotnet@gmail.com
	@wechat 18601767221
	@website ittimeline.net
	@version 2020/01/03
*/

int main(int argc, char* argv[])
{
	//C语言程序的编译是从上到下开始编译的，如果想要调用函数，必须在main方法执行之前实现
	//声明、实现该函数
	swap_with_temp();
	swap_with_arithmetic();
	swap_with_xor();


	system("pause");
	return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
/*

   使用scanf函数读取用户从键盘输入的整数数据
	@author liuguanglei ittimelinedotnet@gmail.com
	@wechat 18601767221
	@website ittimeline.net
	@version 2019/12/18
*/
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>
/*

	使用scanf函数读取用户输入的小数
	@author liuguanglei ittimelinedotnet@gmail.com
	@wechat 18601767221
	@website ittimeline.net
	@version 2019/12/18
*/
int main(int argc, char* argv[])
{
	double salary = 0.0;
	printf("请输入你的工资(按回车结束)\n");
	scanf("%lf",&salary);
	//输出结果小数点后保留2位数
	printf("你的工资是%.2f\n",salary);
	system("pause");
	return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
/*

整数常量
	整数常量分为整型、长整型、长长整型
	同时每种整型还有有符号和无符号两种类型
	@author liuguanglei ittimelinedotnet@gmail.com
	@wechat 18601767221
	@website ittimeline.net
    @version 2019/12/18

*/
int main(int argc, char* argv[])
{
	printf("有符号整数常量%d \n", 100);
	printf("无符号整数常量%d \n", 100u);

	printf("有符号长整数常量%ld \n", 2147483647L);
	printf("无符号长整数常量%lu \n", 2147483647UL);

	printf("有符号长长整数常量%lld \n", 9223372036854775807LL);
	printf("无符号长长整数常量%lld \n", 9223372036854775807ULL);
	system("pause");
	return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
/*
	整数的三种进制输出形式
	C语言不支持二进制输出
	八进制
	十进制
	十六进制
	@author liuguanglei ittimelinedotnet@gmail.com
	@wechat 18601767221
	@website ittimeline.net
	@version 2019/12/18
*/
int main(int argc, char* argv[])
{
	//定义整型变量，初始化值为100
	int number = 100;
	//虽然输出结果有变化，但是原始number的值是没有变化的
	printf("100以八进制输出的结果是%#o\n", number);
	//不同进制的输出不会修改数据，只是数据的表现形式发生了变化。
	printf("100以十进制输出的结果是%d\n", number);
	//# 表示将进制的完整表现形式输出 例如十六进制的值是以0x开头，八进制的值是以0开头
	printf("100以十六进制输出的结果是%#x\n", number);

	system("pause");
	return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
/*

    有符号和无符号的整数常量
	@author liuguanglei ittimelinedotnet@gmail.com
	@wechat 18601767221
	@website ittimeline.net
	@version 2019/12/17
*/
int main(int argc, char* argv[])
{
	// 10默认是有符号
	//有符号整型
	printf("%d \n", 10);
	//10U是无符号数 printf输出无符号int 使用格式 %u
	printf("%u \n", 10U);

	// 有符号长整型
	printf("%ld \n", 10L);
	//无符号长整型
	printf("%lu \n", 10UL);
	system("pause");
	return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
/*

	变量默认是有符号的，如果要声明无符号的变量，使用unsigned声明

	@author liuguanglei ittimelinedotnet@gmail.com
	@wechat 18601767221
	@website ittimeline.net
	@version 2019/12/17
*/
int main(int argc, char* argv[])
{
	//整数变量默认是有符号的
	int age = 26;
	//无符号整数变量
	unsigned int data = 39;
	printf("age =%d \n", age);
	printf("data = %u \n", data);
	system("pause");
	return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
/*

    跨平台的整数
	@author liuguanglei ittimelinedotnet@gmail.com
	@wechat 18601767221
	@website ittimeline.net
	@version 2019/12/18
*/
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>
/*

	三种整数类型的有符号和无符号的极限
	@author liuguanglei ittimelinedotnet@gmail.com
	@wechat 18601767221
	@website ittimeline.net
	@version 2019/12/18
*/
int main(int argc, char* argv[])
{
	printf("short能存储的最大值是%d\tshort能存储的最小值是%d,占据的字节数量是%d\n\n\n", SHRT_MAX, SHRT_MIN, sizeof(short));
	printf("unsigned short能存储的最大值是%d\n\n", USHRT_MAX);
	//32位和64位系统 int和long是等价的
	printf("int能存储的最大值是%d\tint能存储的最小值是%d,占据的字节数量是%d\n\n", INT_MAX, INT_MIN, sizeof(int));
	printf("unsigned int能存储的最大值是%u\n\n", UINT_MAX);
	//无符号的整数 最小值都是0 即不能表示负数
	printf("long能存储的最大值是%d\tlong能存储的最小值是%d,占据的字节数量是%d\n\n", LONG_MAX, LONG_MIN, sizeof(long));
	printf("long long能存储的最大值是%lld\tlong long能存储的最小值是%lld,占据的字节数量是%d\n\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
	@wechat 18601767221
	@website ittimeline.net
	@version 2019/12/18
*/
int main(int argc, char* argv[])
{
	//为了保证结果运算正确，必须在极限范围之内
	printf("无符号short int所能存储的最大值是%d\n", USHRT_MAX);

	unsigned short int  shortnum = 65536;
	printf("shortnum=%d", shortnum); //结果为0 因为chnum所能表示的最大值为65535,这里发生了越界，结果错误
	system("pause");
	return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
/*

    long long 类型的应用场景
	@author liuguanglei ittimelinedotnet@gmail.com
	@wechat 18601767221
    @website ittimeline.net
	@version 2019/12/18
*/
int main(int argc, char* argv[])
{
	unsigned long long mobilePhone = 18601767221;
	printf("mobilePhone=%llu\n", 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 <math.h>
/*
	根据给出的边长求面积
	使用math.h文件中提供的开平方根函数
	@author liuguanglei ittimelinedotnet@gmail.com
	@website ittimeline.net
	@version 2019/12/18
*/
int main(int argc, char* argv[])
{
	//根据给出的边长求面积
	//使用math.h文件中提供的开平方根函数
	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
	@wechat 18601767221
	@website ittimeline.net
	@version 2019/12/19

*/
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
	@wechat 18601767221
	@website ittimeline.net
	@version 2019/12/19
*/
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>
/*

	浮点数的极限
	@author liuguanglei ittimelinedotnet@gmail.com
	@wechat 18601767221
	@website ittimeline.net
	@version 2019/12/19
*/
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>
#include <float.h>
/*

	浮点数的使用注意事项
	@author liuguanglei ittimelinedotnet@gmail.com
	@wechat 18601767221
	@website ittimeline.net
	@version 2019/12/19
*/
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以及增长率，使用math.h的pow函数实现计算出中国GDP超过美国GDP的年份
	@author liuguanglei ittimelinedotnet@gmail.com
	@website ittimeline.net
	@version 2019/12/19
*/
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
	@wechat 18601767221
	@website ittimeline.net
	@version 2019/12/19

*/
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>
/*

	C语言中文存储
	@author liuguanglei ittimelinedotnet@gmail.com
	@wechat 18601767221
	@website ittimeline.net
	@version 2019/12/19

*/
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>
/*

	使用putchar和printf输出字符
	@author liuguanglei ittimelinedotnet@gmail.com
	@wechat 18601767221
	@website ittimeline.net
	@version 2019/12/19

*/
int main(int argc, char* argv[])
{
	char c = ‘A‘;
	putchar(c);
	printf("\n");
	printf("c = %c \n", c);
	system("pause");
	system("pause");
	return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
/*

	字符与asc||码表
	@author liuguanglei ittimelinedotnet@gmail.com
	@wechat 18601767221
	@website ittimeline.net
	@version 2019/12/19
*/
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>
/*

	字符的本质
	@author liuguanglei ittimelinedotnet@gmail.com
	@wechat 18601767221
	@website ittimeline.net
	@version 2019/12/19
*/
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
	@wechat 18601767221
	@website ittimeline.net
	@version 2019/12/19
*/
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>
/*

    字符的大小写转换
	@author liuguanglei ittimelinedotnet@gmail.com
	@wechat 18601767221
	@website ittimeline.net
	@version 2019/12/20
*/
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>
#include <stdbool.h>
/*
	bool类型及其应用
	@author liuguanglei ittimelinedotnet@gmail.com
	@wechat 18601767221
	@website ittimeline.net
	@version 2019/12/19
*/
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;
}

char,short->int->long->float->double->long double

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
/*

    数据类型转换之自动类型转换

	char和int,double的自动类型转换

	@author liuguanglei ittimelinedotnet@gmail.com
	@wechat 18601767221
	@website ittimeline.net
	@version 2020/01/03
*/
int main(int argc, char* argv[])
{
	//大写字符‘A‘会被当作整数65处理
	char ch = ‘A‘;
	//因为char和int运算时会自动转换为int，而整数常量1默认的类型是int
	//因此 ch+1占据的字节数量是4
	printf("字符变量 A+1 占据的字节数量是%d\n",sizeof(ch+1));
	printf("字符‘A‘+1 = %d \n",(ch+1));

	//因为char和double运算时会自动转换为double，而浮点数常量1.0默认的类型是double
	//因此 ch+1.0占据的字节数量是8
	printf("浮点数1.0占据的字节数量是%d\n", sizeof(1.0));
	printf("字符变量 A+1.0 占据的字节数量是%d\n",sizeof(ch+1.0));
	printf("字符‘A‘+1.0 = %.2f\n", (ch + 1.0));


	system("pause");
	return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
/*
	自动类型转换
	有符号类型int转换为无符号类型int
	@author liuguanglei ittimelinedotnet@gmail.com
	@wechat 18601767221
	@website ittimeline.net
	@version 2020/01/03
*/
int main(int argc, char* argv[])
{
	//有符号类型int转换为无符号类型int
	int number1 = -10;
	printf("整数10按照无符号输出的结果是%u\n",number1);

	unsigned int number2 = 5;

	int result = number1 + number2;
	printf("按照有符号整数输出 result = %d \n", result);
	printf("按照无符号整数输出 result = %u \n", result);
	//因为number1按照无符号的结果是4294967286 因此结果是大于0
	number1 + number2 > 0 ? printf("number1 + number2 > 0") : printf("number1 + number2 < 0");
	printf("\n");

	system("pause");
	return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
/*
	自动类型转换
	由于char,short占据的内存空间过小，编译器规定，只要是char,short参与运算，都会自动转换为int类型。
	@author liuguanglei ittimelinedotnet@gmail.com
	@wechat 18601767221
	@website ittimeline.net
	@version 2020/01/03
*/
int main(int argc, char* argv[])
{
	char x = 10;
	int target = x + x;

	short s = 20;
	int short2 = s + s;
	int result = x + s;
	system("pause");
	return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
/*
	强制类型转换
	@author liuguanglei ittimelinedotnet@gmail.com
	@wechat 18601767221
	@website ittimeline.net
	@version 2020/01/03
*/
int main(int argc, char* argv[])
{
	float fl = 10.8;
	float flt = 10.3;

	/*
		运算过程
		首先将10.8强制转换为整型10
		然后将10和10.3运算的结果是20.3
		最后将20.3的结果赋值给int,因为赋值也会发生自动类型转换
		因此最后的计算结果是20
	*/
	int number = (int)fl + flt;
	printf("number = %d \n",number);

	/*
		运算过程
		首先计算10.8+10.3，运算结果是21.1
		然后将21.1转换为整数21
		因此运算结果是21
	*/
	number = (int)(fl + flt);
	printf("number = %d \n", number);

	system("pause");
	return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
/*
	强制类型转换
	@author liuguanglei ittimelinedotnet@gmail.com
	@wechat 18601767221
	@website ittimeline.net
	@version
*/
int main(int argc, char* argv[])
{
	float flt = 3.14f;
	int number = 0;
	number = (int)flt;
	printf("number = %d \n",number);

	//强制类型转换后并没有改变浮点数变量flt的值
	printf("flt = %.2f \n",flt);

	system("pause");
	return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
/*
	数据类型转换与printf函数
	@author liuguanglei ittimelinedotnet@gmail.com
	@wechat 18601767221
	@website ittimeline.net
	@version 2020/01/04
*/
int main(int argc, char* argv[])
{
	double dbl = 3.14;
	//printf在打印输出数据时不会进行自动类型转换，这里输出的是垃圾结果
	printf("dbl = %d \n",dbl);
	
	//如果想要将浮点数以整数的形式输出，需要使用强制类型转换实现 
	printf("dbl = %d \n",(int)dbl);

	int value = 10;
	printf("dbl = %f \n", value);
	printf("dbl = %f \n", (float)value);
	system("pause");
	return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
/*
	使用强制类型转换实现浮点数后三位的四舍五入
	@author liuguanglei ittimelinedotnet@gmail.com
	@wechat 18601767221
	@website ittimeline.net
	@version 2020/01/03
*/
int main(int argc, char* argv[])
{
	printf("请输入四舍五入的三位小数\n");
	double input = 0.0;
	scanf("%lf", &input);


	/*
	计算流程

		四舍
	// 1.234*100=123.4 
    // 123.4+0.5=123 
	// 123/100.0=1.23


	   五入
	// 1.235*100=123.5 123.5+0.5=124 124/100=1.24
	// 1.24>1.235
	// 1.24-1.235=0.05
	//1.235+0.05=1.24
	*/
	
	double result = (int)(input * 100 + 0.5) / 100.0;
	printf("result =%.2f", result);		
	system("pause");
	return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
/*
	账户余额的分大于4分就偷钱
	@author liuguanglei ittimelinedotnet@gmail.com
	@wechat 18601767221
	@website ittimeline.net
	@version 2020/01/03
*/
int main(int argc, char* argv[])
{
	printf("请输入你的账户余额\n");
	double balance = 0.0;
	scanf("%lf", &balance);

	// 12.34*10=123.4 123.4+0.6=124 124/10.0=12.4   12.4>12.34
	double rest = (int)((balance * 10) + 0.6) / 10.0;
	printf("rest = %.2f\n", rest);
	if (rest < balance) {
		//
		printf("可以偷钱%.2f元\n", balance - rest);
	}

	system("pause");
	return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
/*
	数据类型转换的内存原理

	低字节转高字节，按照符号位填充(如果高字节符号位为0，则高位填充0，如果高字节符号位为1，则高位填充1)
	@author liuguanglei ittimelinedotnet@gmail.com
	@wechat 18601767221
	@website ittimeline.net
	@version 2020/01/04
*/
int main(int argc, char* argv[])
{
	//正数的低字节转高字节

	// 字符变量ch 在内存中占据一个字节 1 在内存中表示为 0000 0001
	char ch = 1;
	// 正数变量num 在内存中占据四个字节，1在内存中表示为 0000 0000 0000 0000 0000 0000 0000 0001
	int num = 1;
	// 低字节转高字节按照高位的符号位填充(如果高字节符号位为0，则高位填充0，如果高字节符号位为1，则高位填充1)
	num = ch;

	printf("ch在内存中的地址是%p\tnum在内存中的地址是%p\n",&ch,&num);

	system("pause");
	return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
/*
	数据类型转换的内存原理

	低字节转高字节，按照符号位填充(如果高字节符号位为0，则高位填充0，如果高字节符号位为1，则高位填充1)
	@author liuguanglei ittimelinedotnet@gmail.com
	@wechat 18601767221
	@website ittimeline.net
	@version 2020/01/04
*/
int main(int argc, char* argv[])
{
	//正数的低字节转高字节

	// 字符变量ch 在内存中占据一个字节 1 在内存中(补码)表示为 1111 1111
	// 计算过程 一个字节 -1的原码1000 0001 取反 -> 1111 1110 加1 -> 1111 1111 十六进制表示为ff
	char ch = -1;


	// int 在内存中占据四个字节，1在内存中表示为 1111 1111 1111 1111 1111 1111 1111 1111 十六进制(补码)表示为ffff ffff
	// 四个字节-1的原码 1000 0000 0000 0000 0000 0000 0000 0001 取反 ->  1111 1111 1111 1111 1111 1111 1111 1110 加1 ->  1111 1111 1111 1111 1111 1111 1111 1111 
	int num = -1;
	// 低字节转高字节按照高位的符号位填充(如果高字节符号位为0，则高位填充0，如果高字节符号位为1，则高位填充1)
	num = ch;

	printf("ch在内存中的地址是%p\tnum在内存中的地址是%p\n", &ch, &num);

	system("pause");
	return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
/*
	字符串常量
	一个字符占一个字节
	字符串由多个字符组成

	@author liuguanglei ittimelinedotnet@gmail.com
	@wechat 18601767221
	@website ittimeline.net
	@version 2019/12/21
*/
int main(int argc, char* argv[])
{
	//字符串刘光磊的字节数量是 7 
	//字符串是以\0结尾
	//一个英文字符占据1个字节
	printf("字符串hello占据的字节数量是%d\n",sizeof("hello"));
	//一个中文字符占据2个字节
	printf("字符串刘光磊占据的字节数量是%d\n",sizeof("刘光磊"));

	// ‘‘的作用是表示该内容是一个字符，取字符的ASCII值

	// "hello world" ""的作用 表示该内容是一个字符串 取字符串首个元素(h)的地址
	printf("%s\n","hello world");
	//跳过2个字符输出
	printf("%s\n","hello world"+2);
	//如果按照整型输出时。输出的是字符串首元素的地址
	printf("%d\n","hello world");

	// %s 遇到‘\0‘结束
	//因此这里只会输出hello
	printf("%s\n","hello \0 world");
	//这里会输出空白
	printf("%s\n","\0hello world");



	system("pause");
	return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
/*

    数据的存取
	@author liuguanglei ittimelinedotnet@gmail.com
	@wechat 18601767221
	@website ittimeline.net
	@version 2019/12/20
*/
int main(int argc, char* argv[])
{
	//-15 原码为1000 1111 但是在内存中存储的是补码。因此1000 1111 取反 1111 0000 加1 的结果是1111 0001 ,即-15在内存中的存储二进制表示为1111 0001
	char number = -15;
	//有符号输出 补码 1111 0001 取反 1000 1110 加1  1000 1111 
	printf("number = %d \n ",number);
	//无符号输出 1111  0001  原样输出 即1111 0001转换为十进制输出为241 
	printf("number = %u \n",number&0x00000000ff);

	system("pause");
	return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
/*

	数据的存取
	如果给变量使用16进制赋值，存储数据时，内存原样存储。
	@author liuguanglei ittimelinedotnet@gmail.com
	@wechat 18601767221
	@website ittimeline.net
	@version 2019/12/20
*/
int main(int argc, char* argv[])
{
	//9b 内存中存放的数据为 1001 1011
	char number = 0x9b;

	//有符号取
	// 1001 1011 最高位是1 表示负数的补码，需要取反  1110 0100 加1 1110 0101  转换为十进制就是-101
	printf("number  =%d \n",number);

	//无符号取
	//内存原样输出
	printf("number = %x\n",number&0x00000000ff);
	system("pause");
	return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
/*

    字符类型的取值范围
	@author liuguanglei ittimelinedotnet@gmail.com
	@wechat 18601767221
	@website ittimeline.net
	@version 2019/12/20
*/
int main(int argc, char* argv[])
{
	// 十六进制的0xff 使用二进制表示为1111 1111 然后加2 的结果是1 0000 0001 

	char number = 0xff + 2;

	//有符号获取
	// 1 0000 0001 因为char只能存储一个字节，因此存储的是0000 0001 ，因此输出的结果是1 
	printf("number =%d \n",number&&0x00000000ff);
	 
	//无符号输出  因为char只能存储一个字节，因此存储的是0000 0001 ，因此输出的结果是1 
	printf("number =%x \n",number);

	//十六进制的0x80 转换为二进制是 1000 0000，即为-0的原码
	char zero = 0x80;
	//有符号输出 1000 0000 取反 1 111 1111 加1 1 0000 0000 的结果就是-128
	printf("zero = %d\n",zero);
	 
	system("pause");
	return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
/*

	const 修饰变量为只读，本质还是变量，不能被修改，而且const修饰的变量必须被初始化
	@author liuguanglei ittimelinedotnet@gmail.com
	@wechat 18601767221
	@website ittimeline.net
	@version 2020/01/03
*/
int main(int argc, char* argv[])
{
	const int number = 10;
	//这里会发生编译错误 因为const修饰的变量一旦被初始化后就不能再赋值
	//number = 20;
	const int value;
	//程序运行时会出错 error C4700: 使用了未初始化的局部变量“value”
	//printf(" value  = %d \n",value); 
	system("pause");
	return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
/*

    register 寄存器变量
	@author liuguanglei ittimelinedotnet@gmail.com
	@wechat 18601767221
	@website ittimeline.net
	@version 2020/01/04
*/
int main(int argc, char* argv[])
{
	//寄存器变量的声明
	register int location = 100;
	location = 200;

	printf("location = %d \n",location);
	//这里运行会报错，register修饰的变量是寄存器变量，不能获取内存地址 &表示获取内存地址
	//printf("location =%p",&location);
	system("pause");
	return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
/*
	volatile 防止编译器优化代码
	@author liuguanglei ittimelinedotnet@gmail.com
	@wechat 18601767221
	@website ittimeline.net
	@version 2020/01/05
*/
int main(int argc, char* argv[])
{
	volatile int num = 10;
	num = 10;
	num = 10;
	num = 10;
	num = 10;
	num = 100;

	system("pause");
	return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
/*
	extern 声明变量，并没有开辟存储空间
	@author liuguanglei ittimelinedotnet@gmail.com
	@wechat 18601767221
	@website ittimeline.net
	@version 2020/01/05
*/

//此时并没有开辟存储空间 ，在声明时不用赋值，否则会引发变量“重定义，多次初始化的编译错误”。
extern int num;

int main(int argc, char* argv[])
{
	printf("num = %d\n", num);
	system("pause");
	return 0;
}
//但是如果最终变量没有定义在使用之后，程序运行时还是会出现异常，例如这里如果注释int num = 20; 就会出现 无法解析的外部符号 num。
int num = 20;