C语言学习笔记01：C语言基础语法_变量类型_类型转换

C语言第一天课程笔记

每一天的笔记包含如下内容:

1. 当天授课内容安排
2. 课堂重点内容笔记
3. 课后思考题

1. 内容安排

第一节课: 课程概述、计算机硬件/软件
第二节课: 操作系统的作用、编程语言与编译器的作用、编程语言发展历程、C语言标准/优缺点
第三节课: vs使用(创建项目、设置字体、大小)、第一个C语言程序
第四节课: #include 指令作用、main函数、代码块、print函数
第五节课: 注释(注释的编写、如何写注释)、断点调试(逐步、逐过程、跳出)
第六节课: C程序编译过程

2. 课堂笔记

课堂主要内容、重要内容。

2.1 计算机硬件

CPU： 计算和控制。计算包含逻辑运算、数值运算等。控制外部硬件设备。CPU执行程序。执行速度非常快。

内存：电信号存储数据，读写速度快，缺点是断电数据丢失。

硬盘：磁信号存储数据，读写速度慢，优点可以持久存储数据。

硬盘中的数据都需要加载到内存中，CPU只从内存中读写数据，当内存中的数据想要长久你保存，必须要写入到磁盘。（文件读写）

2.2 计算机软件

操作系统： 对下进行硬件管理、对上给用户提供操作方式，图形界面普通用户）、终端命令(开发人员)、系统调用(开发人员)

2.3 编程语言和编译器

编程语言：告诉CPU要做什么事情，控制计算机硬件。编程语言就是文字和符号的组合。我们学编程语言最主要学习这些符号和文字的组合规则。

编译器：编译器是一个程序，负责将人能够读的代码转换成计算机能够识别的代码(0001010101010)。

2.4 编程语言发展

00001010101
01010101010
00000001101

汇编语言： 移植性比较差。编码比较复杂。维护性比较差。

2.5 C语言标准

ANSI/IOS C语言标准就是一本对C语言说明的书。

微软 、Borland 、Intel、开源组织等进行C语言开发(开发编译器)，既然是说明书，厂商可以选择性放弃某些规则，优化规则，各个编译器之间会有一些差异。

C标准: C89 C99 C11,如果用到了某个语法，编译器报错，该编译器不支持。

写程序一定要知道：编译器 标准。gcc对标准支持最好。 Linux 用 gcc

微软：vc++ 宝蓝：bcc 、intel c++

2.6 C语言学习理由

1. 速度快，效率高
2. 啥都能干

缺点：代码量多一些。

2.7 上午自习任务

1. 代码片段管理器添加到你的vs里， 按 #1 + tab 能够添加代码。
2. C语言第一个程序写3遍
3. 笔记过一遍，重要概念看一遍。
4. 预习下午内容.

2.8 main 函数作用

main函数是程序的入口点，操作系统运行程序的时候从main函数开始执行。

一个程序只能有一个main函数。

main 函数两种写法:

int main()
{
     
	return 0;
}

void main()
{
     
	
}

项目开发中写第一种。

2.9 #include 包含

使用工具箱(包含头文件)，在每一个被导入的工具箱中都定义了一系列相关的、已经写好的功能函数。如果想使用:

1. 导入
2. 使用

工具箱分为两种：C语言自带的(#include <>, 告诉编译器去系统目录下找 )、自定义(#include "",告诉编译器在当前目录下找)

2.10 注释

注释：就是在程序中添加一些解释说明文字。被注释的代码、文本，编译器不会编译执行。

C语言中添加注释有三种方式:

第一种

// 第一行注释文本
// 第二行注释文本

尽量不要在代码后侧去写。

第二种

/*
		注释内容
		注释内容
		注释内容
*/

/* 注释内容 */

第三种

#if 0
	所有之间代码都会被注释
#endif

大部分公司都有编码规范，注释规范，按照公司要求编写注释。

如果公司没有规范，三种可以选择，尽量不要混用注释。尽量保持注释风格统一。

VS里有注释的快捷键：注释-ctrl+k, c 解除注释 ctrl+k,u

什么情况下写注释:

1. 可以写代码的实现思路
2. 代码比较有技巧，增加注释解释说明
3. 文件注释
4. …

2.11 调试

在代码上前面单击，可以在改行增加断点。当程序执行到断点时，程序就会停止。

逐语句：碰到代码是一个功能，会进入到功能内部继续按行执行。

逐过程：碰到代码是一个功能，不会进入到功能内部执行。

跳出：跳出功能内部，回到外部。

增加断点快捷键： F9

2.12 编译四个步骤

2.13 变量的作用及其命名规则

程序用来处理数据。待处理的数据要能够保存，用变量来保存数据。

变量其实就是一块内存空间，这块内存空间中存储的值可以修改的。

变量: 变量名字 变量的地址 变量的空间大小。

int a = 10;  // 分配空间，把10存储到a这个空间中。  printf("%p", &a);
int b = 20;
int c = a + b;

程序结束之后，a b c三个变量的值是否还存在？数据就不存在了。

变量用来存储程序运行过程中所需要的临时数据。

练习:

fromNo12
from#12
my_Boolean
my-Boolean
Obj2
2ndObj
myInt
test1
Mike2jack
My_tExt
_test
test!32
haha(da)tt
int
jack_rose
jack&rose
GUI
G.U.I

C语言第二天课程笔记

每一天的笔记包含如下内容:

1. 当天授课内容安排
2. 课堂重点内容笔记
3. 课后思考题

1. 内容安排

第一节课: 变量的命名规则、变量的命名规范、变量名练习、变量的类型
第二节课: 整型变量的输入和输出(1)
第三节课: 整型变量的输入和输出(2)
第四节课: 进制转换(手动转换、进制输出、进制赋值、程序转换)
第五节课: 字符类型(定义大小存储、相关操作、练习、转义字符)
第六节课: 浮点数类型

2. 课堂笔记

课堂主要内容、重要内容。

2.1 变量命名规则

回顾: 变量的作用就是临时存储程序运行过程中需要的数据。

变量：变量名、变量地址、变量值，在程序中可以通过变量名、地址来操作变量(读写变量)。

int a = 10;  // int类型、a变量名、10值

变量名命名规则:

1. 标识符不能是关键字
2. 标识符只能由字母、数字、下划线组成
3. 第一个字符必须为字母或下划线
4. 标识符中字母区分大小写

变量名定义要求: 变量名一定要见名知意。

变量名规范:

1. 小驼峰法: 变量由多个单词构成则首个单词小写，后面单词首字母大写. 如果一个单词则小写。userNameAge

2. 大驼峰法: 变量由多个单词构成则所有单词首个字母大写。如果一个单词，则首字母大写。UserNameAge

3. 小写+下划线: 单词之间使用下划线相连。 C语言中该命名方法居多。user_name_age

在C语言，用小写+下划线最多。

练习:

fromNo12
from#12
my_Boolean
my-Boolean
Obj2
2ndObj
myInt
test1
Mike2jack
My_tExt
_test
test!32
haha(da)tt
int
jack_rose
jack&rose
GUI
G.U.I

2.2 变量类型

1. 指定变量开辟多大的内存空间来存储数据。 int a = 10;
2. 指定数据能否进行运算，以及运算规则是什么。

类型分类:

1. 基本数据类型， 编译器内置的数据类型 int，同一个系统同一个编译器大小是一样的。

   1. 整型（short、int、long、long long）
   2. 浮点型
   3. 字符型

2. 自定义数据类型，大小和定义有关系

3. 指针类型。基本类型的指针、自定义类型的指针。

每一种类型的：空间大小、取值范围、该类型输出、类型的输入、有符号类型和无符号类型

只有整数类型才有符号和无符号之分，小数不分。

signed int a = 100;  // 有符号的变量，既可以存储正数、也可以存储负数
unsigned int b = 100;  // 有符号的最小值 0

2.3 short 类型变量的输入和输出

#if 1
#define _CRT_SECURE_NO_WARNINGS
#include 
#include 
#include 
#include 

// C语言常量
#define MAX_VALUE 1000000

// 1. short 类型的输入和输出
void test01()
{
     
	// 1.1 无符号、有符号 short 类型的输入和输出
	short s = 100;
	printf("有符号 short 类型 s 变量的值是: %hd\n", s);
	unsigned short us = 100;
	printf("无符号的 short 类型 us 变量的值是: %hu\n", us);


	// 1.2 short 类型占用的内存大小 sizeof
	int short_size = sizeof(short);  // 先执行等号右侧， 将结果赋值给等号左侧的变量
	printf("short 类型占用的内存大小是: %d\n", short_size);
	printf("short 类型占用的内存大小是: %d\n", sizeof(short));
	printf("unsigned short 类型占用的内存大小是: %d\n", sizeof(unsigned short));

	// 1.3 short 类型和 unsigned short 类型的取值范围
	printf("short 类型最小值是: %hd, 最大值是: %hd\n", SHRT_MIN, SHRT_MAX);
	printf("unsiged short 类型最小值: 0, 最大值是: %hu\n", USHRT_MAX);

	// 1.4 short 类型输入操作  scanf
#if 0
	short shrt_number = 0;
	printf("请输入一个 short 类型的数字:");
	// %hd 表示按照 short 类型输入， &shrt_number 表示键盘输入数据之后，数据存储到内存中哪个位置
	scanf("%hd", &shrt_number);  // 阻塞等待
	printf("您输入的 short 类型的值是: %hd\n", shrt_number);
#endif

	unsigned short ushrt_number = 0;
	printf("请输入一个 unsigned short 类型的数字:");
	scanf("%hu", &ushrt_number);
	printf("您输入的 unsigned short 类型的值是: %hu\n", ushrt_number);
}


// 2. int 类型的输入和输出
// 3. long 类型的输入和输出
// 4. long long 类型的输入和输出

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

	test01();

	system("pause");
	return 0;
}
#endif

2.4 int 类型变量的输入和输出

#if 1
#define _CRT_SECURE_NO_WARNINGS
#include 
#include 
#include 
#include 

// C语言常量
#define MAX_VALUE 1000000

// 2. int 类型的输入和输出(整型)
void test02()  // 函数  名字叫做 test02, 执行函数要调用
{
     

	// 2.1 int 类型和 unsigned int 类型输入和输出
	int i = 100;
	printf("i = %d\n", i);
	unsigned int ui = 666;
	printf("ui = %u\n", ui);


	// 2.2 int 类型占用的内存大小(4字节)
	printf("int 类型占用的内存大小: %d\n", sizeof(int));
	printf("unsigned int 类型占用的内存大小: %d\n", sizeof(unsigned int));


	// 2.3 有符号、无符号类型取值范围
	printf("int 类型的最小值:%d, 最大值:%d\n", INT_MIN, INT_MAX);
	printf("unsigned int 类型最小值: 0, 最大值: %u\n", UINT_MAX);


	// 2.4 int类型 变量输入
	int inumber = 0;
	printf("请输入 int 类型的值:");
	scanf("%d", &inumber);
	printf("您输入的 int 类型的值是: %d\n", inumber);

	unsigned int uinumber = 0;
	printf("请输入 unsigned int 类型的值:");
	scanf("%u", &uinumber);
	printf("您输入的 unsigned int 类型的值是: %u\n", uinumber);

}

// short < int(long) << long long

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

	test02();

	system("pause");
	return 0;
}
#endif

2.5 long 类型变量的输入和输出

#if 1
#define _CRT_SECURE_NO_WARNINGS
#include 
#include 
#include 
#include 

// C语言常量
#define MAX_VALUE 1000000

// 3. long 类型的输入和输出（长整型）
void test03()
{
     
	
	// 1. long 类型和 unsigned long 类型输出
	long l = 888;
	printf("l = %ld\n", l);
	unsigned long ul = 888;
	printf("ul = %lu\n", ul);

	// 2. long 类型占用的内存大小
	// long 的大小不能比 int 小
	// gcc 编译器 long 类型占8个字节
	printf("long 的内存大小是:%d\n", sizeof(long));

	// 3. long 取值范围
	printf("long 类型的最小值:%ld, 最大值:%ld\n", LONG_MIN, LONG_MAX);
	printf("unsigned long 类型最小值: 0, 最大值:%lu\n", ULONG_MAX);

	// 4. long 输入
	long lnumber = 0;
	scanf("%ld", &lnumber);
	printf("lnumber = %ld\n", lnumber);

	unsigned long ulnumber = 0;
	scanf("%lu", &ulnumber);
	printf("ulnumber = %lu\n", ulnumber);
}

// short < int(long) << long long

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

	test03();

	system("pause");
	return 0;
}
#endif

2.6 2long long 类型变量的输入和输出

#if 1
#define _CRT_SECURE_NO_WARNINGS
#include 
#include 
#include 
#include 

// C语言常量
#define MAX_VALUE 1000000

// 4. long long 类型的输入和输出
void test04()
{
     
	
	// 1. long long 类型输出
	// 有些编译器不支持 long long 类型
	long long ll = 100;
	printf("ll = %lld\n", ll);

	unsigned long long ull = 100;
	printf("ull = %llu\n", ull);

	// 2. long long 内存大小
	printf("long long 类型的内存大小: %d\n", sizeof(long long));

	// 3. 取值范围
	printf("long long 类型的最小值:%lld, 最大值:%lld\n", LLONG_MIN, LLONG_MAX);
	printf("unsigned long long 类型的最小值: 0, 最大值: %llu\n", ULLONG_MAX);

	// 4. long long 输入
	long long llnumber = 0;
	scanf("%lld", &llnumber);
	printf("llnumber = %lld\n", llnumber);


	unsigned long long ullnumber = 0;
	scanf("%llu", &ullnumber);
	printf("ullnumber = %llu\n", ullnumber);
}

// short < int(long) << long long

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

	test04();

	system("pause");
	return 0;
}
#endif

2.7 字符类型

#if 1
#define _CRT_SECURE_NO_WARNINGS
#include 
#include 
#include 
#include 
#include 

// 1. 字符语法(字符变量的定义、输入和输出、字符的内存大小、字符的存储原理、字符取值范围)
void test01()
{
     

	// 1.1 字符变量的定义、输出
	char c1 = 'a';
	char c2 = '1';  // 区分数字1和字符1
	printf("c1 = %c\n", c1);
	printf("c2 = %c\n", c2);


	// 1.2 字符占用内存大小(1)
	printf("char 类型内存大小: %d\n", sizeof(char));


	// 1.3 字符存储, 字符在存储的时候实际存储的是一个数字。 ascii 码表
	printf("c1 = %d\n", c1);
	char c3 = 68;
	printf("c3 = %c\n", c3);

	// 1.4 char 类型取值范围
	printf("char 的最小值:%d, 最大值:%d\n", CHAR_MIN, CHAR_MAX);
	printf("unsigned char 的最小值: 0, 最大值:%d\n", UCHAR_MAX);

	// 1.5 char 输入
	char c4 = 0;
	scanf("%c", &c4);
	printf("c4 = %c\n", c4);

}


// 2. 字符简单操作
void test02()
{
     
	char c1 = 'a';
	char c2 = 'B';

	// 如果需要使用字符处理函数(功能)， 需要导入头文件 ctype.h
	// 2.1 把字符转换为大写
	char c3 = toupper(c1);  // 将c1值转换成大写并返回，c1 仍然小写的
	printf("c3 = %c, c1 = %c\n", c3, c1);

	// 2.2 把字符转换为小写
	char c4 = tolower(c2);
	printf("c4 = %c, c2 = %c\n", c4, c2);

	// 2.3 把字符转换为 ascii 码值
	int ascii_val = toascii(c1);
	printf("ascii_val = %d\n", ascii_val);
}


// 3. 练习: 从键盘输入任意一个字母，将其转换为大写并输出
void test03()
{
     
	printf("请输入任意一个字母:");
	char c = 0;
	scanf("%c", &c);

	char upper_char = toupper(c);
	printf("您输入的字母是: %c\n", upper_char);
}


// 4. 转义字符
// \a \b \n \t \\ \" \022 \x22 %%
// 字符本身具有一定的意义，加上反斜杠之后就变成另外的意思。转义
void test04()
{
     
	// 1. 警报
	// printf("\a");

	// 2. \b 退格，删除键
	// printf("abcd\b");

	// 3. \n 换行
	// char c = '\n';
	// printf("abc\n");

	// 4. \t 制表符 tab键
	// printf("Name\tAge\n");
	// printf("Trump\t56\n");

	// 5. "\\" 输出一个"\"
	// printf("\\t");

	// 6. \" 输出一个双引号
	// printf("\"");

	// 7. %%  %d %c %hd %u 占位符
	// printf("99.9%%");

	// 8. \0dd
	// printf("\022");  // 21
	// printf("\x22");

}


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


	system("pause");
}
#endif

2.8 进制转换

十进制： 逢十进一， 0-9

二进制：逢二进一， 0-1

八进制：逢八进一，0-7

十六进制：逢十六进一，0-F

十进制转二进制

小数转二进制

#if 1
#define _CRT_SECURE_NO_WARNINGS
#include 
#include 
#include 

// 1. 进制的赋值、输出
void test01()
{
     
	// 程序不支持二进制赋值
	// 程序不支持二进制输出

	int a = 12;  // 十进制赋值  12
	int b = 012;  // 八进制    10   oct
	int c = 0x12; // 十六进制   18   hex

	printf("a = %d\n", a);
	printf("b = %d\n", b);
	printf("c = %d\n", c);

	printf("a = 0%o\n", a);
	printf("a = 0x%x\n", a);
}

void test02()
{
     
	int number = 38;

	// char bin[128] 申请指定大小的内存空间
	//  = { 0 } 表示将 128字节空间全部清空
	char bin[128] = {
      0 };

	// 第一个值表示要进行进制转换的值
	// 第二个值表示进制转换完毕之后，将结果存储到哪个内存中
	// 第三个值表示要进行二进制转换、八进制、十六进制、32进制.... 2^n次方
	_ltoa(number, bin, 2);  // "0101010101"
	printf("%s\n", bin);


	char oct[128] = {
      0 };
	_ltoa(number, oct, 8);
	printf("%s\n", oct);


	char hex[256] = {
      0 };
	_itoa(number, hex, 16);
	printf("%s\n", hex);
}


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

	system("pause");
}
#endif

2.9 浮点类型

float 精度：6-7， 6位准确，7位不保证准确

double精度: 15-16,15位准确，16不保证准确

float 和 double 取值范围很大，但是精度不高，当输入一个浮点数时，编译器会将其精确到某一个近似值上。

C语言第三天课程笔记

每一天的笔记包含如下内容:

1. 当天授课内容安排
2. 课堂重点内容笔记
3. 课后思考题

任务:

1. 今天内容代码敲完(2遍)，需要推演自己推演一遍。
2. 今天强化训练题。
3. 回顾整体三天学习的内容，xmind 方式。
4. 预习。

1. 内容安排

第一节课: 数值溢出
第二节课: 类型转换
第三节课: 整型存储原理(原码、反码、补码)
第四节课: 数据类型总结(printf函数、变量命名规则、类型大小、变量声明和定义、变量和常量、变量初始化问题)
第五节课: C语言运算符(算数运算符、比较运算符、赋值运算符、比较运算符、运算符优先级)
第六节课: 数据强化训练(结转到下一天)

2. 课堂笔记

课堂主要内容、重要内容。

2.1 数值溢出

整型溢出：

1. 当无符号类型，达到上限的话，值会回到原点。如果达到下限，再进行计算，值回到最大值。
2. 当有符号类型，达到上限再+1的话，值会回到最小值。如果达到下限，再减一，值会回到最大值。（编译器行为， C语言只规定无符号类型溢出的规则，对于有符号类型并没有做出规定，当有符号数据溢出时，结果 undefined 未定义）

浮点数溢出:

1. 当浮点数上溢出，编译器会用一个词表示无穷大(vs inf)。
2. 当浮点数下溢出，指数会向尾部部分借位，尾数减少一位。

练习:

// 1. 请问 c1 输出的值是多少? 
	unsigned char c1 = CHAR_MAX;
	printf("c1 = %hhu\n", c1 + 1);

	// 2. 请问 c2 输出的值是多少？
	unsigned char c2 = CHAR_MIN;
	printf("c2 = %hhu\n", c2);

	// 3. 请问 c3 输出的值是多少?
	char c3 = UCHAR_MAX;
	printf("c3 = %hhd\n", c3);

	// 4. 请问 s1 输出的值是多少?
	short s1 = CHAR_MAX;
	printf("s1 = %hd\n", s1);

	// 5.     请问 s2 输出的值是多少?
	short s2 = USHRT_MAX;
	printf("s2 = %hd\n", s2);

	// 6. 请问 s3 输出的值是多少?
	unsigned short s3 = SHRT_MAX +1;
	printf("s3 = %hu\n", s3);

2.2 类型转换

C语言允许不同数据类型之间进行类型转换。类型转换分为：

1. 自动类型转换.
2. 强制类型转换.

自动类型转换:

**1. 运算中类型转换: **如果两个不同类型之间数据运算，先要将其转换为相同类型，再进行计算。

1. 两个 float 类型会转换为 double 类型再进行运算， 结果也是 double 类型(不同编译器可能有不同规则)
2. long 类型和 int 类型运算，一般会将其转换为 long 类型，再进行运算，结果是 long 类型。
3. 这些转换由系统自动完成。

2. 赋值中的类型转换: 把等号右侧的值转换为等号左侧值的类型。

1. 浮点类型转换为整型，会舍弃小数部分。整型转换为浮点类型，值不变，只是将值的形式该成浮点形式。
2. float 转换为 double 类型，在尾部加 0 变成 double 类型。 double 类型转换为 float 类型，舍弃部分精度。
3. char 类型转换为 int 类型，一般仍保留原值(ASCII)。int 转换为 char 类型，高位字节舍弃。
4. int 类型转换为 long 类型，直接转换。long 类型转换为 int 类型则舍弃高位字节。
5. int long 转换为 unsigned 类型

类型转换结论:

1. 从代码阅读角度，强制类型转换更加好， 代码表达更加清晰。

2. 从代码控制角度，强制类型转换更加好，我们更加准确的控制不同类型之间的运算。

3. 语法：(类型名)变量名

十六进制和二进制转换:

**思考: **输入结果是？

void test01()
{
     
	int n = 0xab65; 
	char a = (char)n;
	printf("a = %d\n", a);
	n = a;
	printf("n = %d\n", n);
}

2.3 整型存储(原码反码补码)

1. 负数的反码存储，主要用于解决：正数+负数
2. 负数的补码存储，主要用于解决：负数+负数

整数在内存中都是以补码形式存储。

1. 正数的原码、反码、补码都是本身。

2. 负数的补码是反码+1.

3. char 类型，有些编译器把 char 类型当做 unsigned char, 有些编译器会把 char 当做负数，还有一些编译器正负来用。

4. char 类型最小值是-128，而不是-127的原因。在整型中，0分为+0和-0，-0没有意义，-0在计算机中-128表示。 char c = -128. 10000000.

2.4 数据类型总结

1. %e, 以指数的形式，需要的是 double 类型变量。

2. printf 函数只有碰到 \n 的时候，才会将内容发送到屏幕去显示。在 vs 里，每次系统会帮我们自动刷新，所以不写\n 也可以输出，但是在其他平台可能就不会输出了。

3. 在C语言中，一行可以定义多个变量。例如:int a=10, b = 20, c= 30;。

4. 在C语言中定义常量，使用#define 常量名字 常量值。 常量和变量区别:

   1. 常量没有内存。
   2. 变量有内存。

5. 变量定义会分配内存，变量声明不会分配内存。有些变量在其他文件中定义，那么如果想在当前文件内使用的话，就必须要先声明，告诉编译器该变量在其他文件定义，不在当前文件，让编译器去其他文件中找变量定义。

   extern 变量类型 变量名;

6. char 类型 1字节，最小1字节
   short类型 2字节，最小2字节
   int类型 4字节，最小2字节
   long 类型 4字节，最小4字节
   long long 类型 8字节，最小8字节
   float 类型 精度6-7位，要求6位
   double 类型 精度15-16位，要求10位

2.5 C语言运算符

#if 1
#define _CRT_SECURE_NO_WARNINGS
#include 
#include 
#include 
#include 
#include 

// 1. 算数运算符
// 常见的算数运算：加、减、乘、除、余数
// 自增(前置、后置)、自减(前置、后置)
// 指数计算、平方根计算
// 左值、右值理解
void test01()
{
     
	int a = 10;
	int b = 20;

	int ret = a + b;
	ret = a - b;
	ret = a * b;
	
	// 注意: 两个整型相除，结果还是整型
	double dr = (double)a / (double)b;
	printf("dr = %f\n", dr);
	// 取余数、取模
	ret = a % b;
	printf("ret = %d\n", ret);
}

void test02()
{
     
	int a = 10;
	// a++; //后置++， 先使用，再++, 主要在表达式中
	// ++a;  // 前置++， 先++，再使用

#if 1
	printf("a = %d\n", a++);
	/*
	printf("a = %d\n", a);
	a = a + 1;
	*/
	printf("a = %d\n", a);
#else

	printf("a = %d\n", ++a);
	/*
	a = a + 1;
	printf("a = %d\n", a);
	*/
#endif
}



void test03()
{
     
	int a = 10;
#if 0
	printf("a = %d\n", a--);
	/*
	printf("a = %d\n", a);
	a = a - 1;
	*/
	printf("a = %d\n", a);
#else
	printf("a = %d\n", --a);
	/*
	a = a- 1;
	printf("a = %d\n", a);
	*/

#endif
}

void test04()
{
     
	int a = 10;
#if 0
	int b = a++;
	/*
	int b = a;
	a = a + 1;
	*/
#else
	int b = --a;
	/*
	a = a - 1;
	int b = a;
	*/
#endif
	printf("b = %d\n", b);
}

void test05()
{
     
	double a = 10;
	double b = 2;

	// 求 a 的 b 次方
	double ret = pow(a, b);
	printf("ret = %lf\n", ret);
	// 开根号
	// 如果参数是 double 类型， 使用 sqrt
	// 如果参数是 float 类型， 使用 sqrtf
	// 如果参数是 long double 类型，使用 sqrtl
	double c = sqrt(ret);
	printf("c = %lf\n", c);
}

void test06()
{
     
	// 能够放在等号左边，被赋值叫做左值
	// 只能放在等号右边，给别人赋值，叫做右值
	// 常量(字面量)只能做右值
	// 变量是左值, 也可以当做右值
	int a = 10;
	int b = a;

}

// 2. 赋值运算符
void test07()
{
     
	// =号叫做赋值运算符
	// 赋值运算符的运算顺序是从右到左
	int a = 10; 

	a += 3; // a = a + 3;
	a -= 3; // a = a - 3;
	a *= 3; // a = a * 3;
	a /= 3; // a = a / 3;
	a %= 3; // a = a % 3;
}


// 3. 比较运算符
// 3.1 真假的理解(非0的值表示真true，0值表示假false)
// 3.2 C99标准 布尔类型(true, false)  stdbool.h
// 3.3 常用的比较运算符
void test08()
{
     
	// 使用布尔类型，需要导入头文件 stdbool.h
	// 布尔类型的值只有两个: true、false
	// 编译器支持 C99 标准的话，才能使用 _Bool 类型
	_Bool a = true;
	_Bool b = false;
}

void test09()
{
     
	int a = 10;
	int b = 20;

	_Bool ret = a > b;
	printf("ret = %d\n", ret);

	ret = a >= b;  // 大于等于
	ret = a < b;  // 小于
	ret = a <= b;  // 小于等于
	ret = a == b;  // 等于
	ret = a != b;  // 不等于

	int rr = a > b;
	// 如果表示真假、建议用 _Bool
	// C程序中，很多地方表示真假的时候用的还是 int 类型， 原因： 只有C99才支持
}


// 4. 逻辑运算符
// 4.1 了解常用逻辑运算符
// 4.2 了解逻辑运算符的运算规则
void test10()
{
     
	int a = 10;
	int b = 20;
	int c = 30;

	// 1. || 或运算，只要有一个条件为真，则整个条件的结果就为真
	_Bool ret = a < b || c > b; // 假 || 真
	printf("ret = %d\n", ret);

	// 2. && 与运算，条件都为真，则结果为真
	// 运算顺序从左向右，如果某个条件能够决定整个运算结果，编译器不再计算后续表达式
	ret = a > b && c > b && a < c;  // 假 && 真 = 假
	printf("ret = %d\n", ret);

	// 3. ! 非
	ret =  !(a > b);
	printf("ret = %d\n", ret);

	ret = !a;
	printf("ret = %d\n", ret);

}


void test11()
{
     
	int a = 10;
	int b = 20;
	int c = 30;

	_Bool ret = a > b && (c > b && a < c);  // 假 && 真 = 假
	printf("ret = %d\n", ret);

	int ret = (a + b) * c;
}

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


	system("pause");
}
#endif

2.6 数据强化训练

1. 对下面的各种数据使用合适的数据类型?

   a. 保存北京的人口

   b. 保存员工的工资

   c. 保存当前文档中出现次数最多的字母

   d. 保存当前文档中某个字母的出现次数

2. 说出下列值的类型?

   a. ‘\t’

   b. 1088

   c. 88.66

   d. 0xAA

   e. 3.14f

   f. 2.0e+30

3. 请说出下列程序中有哪些错误?

   include <stdio.h>
   
   main()
   (
     float g; h;
     float tax, rate;
     g = e12;
     tax = rate * g;
   )
   

4. 指出表中各个常量的数据类型，以及在 printf 输出中的占位符:

   常量	说明符	类型
   12
   0x3
   ‘B’
   2.34e07
   ‘\040’
   7.0
   6L
   6.0f
   012
   ‘s’
   100000
   ‘\n’
   20.0f
   0x44
   2.7e-20

5. 假设 ch 为 char 类型变量，使用转义字符、十进制、八进制、十六进制等方式将其赋值为换行符。

6. 说出下列转义字符的含义:

   a. \r

   b. \\

   c. \*

   d. \t

   e. %%

7. 编写程序，要求输入一个 ASCII 码值(如：66), 输出相应字符。

8. 编写程序，发出警报声，并打印下列文字：

   警报声已经响起，请自觉遵守规则.
   

9. 编写程序，输入一个浮点数，并分别以小数形式和指数形式打印，输出如同下面格式:

   您输入的是: 21.290000，指数形式为: 2.129000e001。
   

10. 一年约有 3.156 x 10⁷ 秒, 编写程序，要求输入年龄，然后显示该年龄有多少秒?

11. 一英寸等于 2.54 厘米, 编写程序，输入您的身高，然后显示身高值等于多少厘米？

12. 下面那几个是 C 的关键字：

    a. main

    b. int

    c. function

    d. char

    e. =

13. 编写程序，创建一个名为 toes 的整数变量，并设置初始值为 10，计算两个 toes 的和、toes 的平方值，并输出这三个值。

print("如果文章对你有用，请点个赞呗O(∩_∩)O~")

System.out.println("如果文章对你有用，请点个赞呗O(∩_∩)O~");

cout<<"如果文章对你有用，请点个赞呗O(∩_∩)O~"<<endl;