笔者在编制应用程序时有这样的要求：将运算的结果（
浮点数
）存入EEPROM中。我们知道，
浮点数
在C语言中是以IEEE格式存储的，一个
浮点数
占用四个字节，例如
浮点数
34.526存为（160，26，10，66）这四个数。要将一个
浮点数
存入EEPROM，实际上就是要存这四个数。那么如何在程序中得到一个
浮点数
的组成数呢？
浮点数
在存储时，是存储连续的字节中的，只要设法找到存储位置，就可以得到这些数了。可以定义一个void的指针，将此指针指向需要存储的
浮点数
，然后将此指针强制转化为char型，这样，利用指针就可以得到组成该
浮点数
的各个字节的值了。具体程序如下：
#define uchar u
JavaScript：定义行为和动作
(基于对象和事件驱动的客户端脚本语言；也是一种广泛应用于客户端Web开发的脚本语言)
基于对象：网页中的一切元素都是假象！不需要new，即可直接使用
事件驱动：JavaScript的执行都是由事件引发
解释执行：先读到的先执行，后读到的会替代先读的
可以使用任何文本编辑工具编写 JavaScript 代码，然后由浏览器解释执行。
JavaScript
常
用于实现如下功能：
|--控制文档的外观和内容；
|--对浏览器的控制；
|--与 HTML 表单的交互；
|--与用户的交互；
|--执行计算等。
1.单击事件：定义在按钮的开始标签中
语法：onclick="js语句"
弹出警告：alert(‘字符串’)
强调：1.js区分大小写
2.字符串单双引号不区分
[removed]标签：页面中专门集中编写JavaScript的区域
js的方法定义：function方法名([参数列表]){
[return 返回值]
注意：js中的方法可以直接写在代码中，不需要“类”包裹
使用方法：方法名()-->方法调用-->立即执行
2.js文件：网页外专门保存js脚本的文件--推荐
强调：HTML、CSS、JS都要使用UTF-8编码保存(window系统)
使用js文件引入网页：[removed][removed]
强调：一旦定义src属性则其中的代码失效
解释执行：语句也可以直接写在js文件中，边解释边执行
3.***调试***
|--①.只有在执行时，才会报错
|--②.错误信息，浏览器页面看不到--没效果
| 解决：控制台--（工具-->JavaScript控制台或F12）
| 包含错误信息；指向错误位置的超链接
|--③.打桩：在指定变量位置输出变量或对象的内容
console.log(内容);-->出现在控制台-->日志
4.变量：js中的变量不需要提前指定类型，由
赋值
时动态决定
所有的变量都用var声明
5.数据类型：
|--String(字符串类型)
|--Number(数字类型)
|--Boolean(布尔类型)0、-0、null、""、false/undefined或NaN,则该对象设置为false。其余都可以当true
6.数据类型的隐式转换：
|--数字 + 字符串：数字转换为字符串
|--数字 + 布尔值：true转换为1，false转换为0
|--字符串 + 布尔值：布尔值转换为字符串true或false
|--布尔值 + 布尔值：布尔值转换为数值1或0
7.数据类型转换函数 ：(方法前不需要对象调用的：全局函数)
|--toString()：转换成字符串。所有数据类型均可转换为 string 类型；
|--parseInt()：强制转换成整数。如果不能转换，则返回 NaN（not a number）；
|--parseFloat()：强制转换成
浮点数
。如果不能转换，则返回 NaN(Not a Number)
|--typeof()：查询数值当前类型。
|--isNaN()：判断是否为数字。返回 true：不是数字/false：是数字
| |--isNan(""):对空字符串不验证，直接返回false
| |--如果输入的是字符串类型的数字，返回false--不能判断数据类型，只判断内容
| |--如果输入的是boolean，返回false。因为boolean可以和number类型直接做计算
| |--和任何数字计算都得NaN;和任何数字作比较都得false
|--注：[removed]();节点输出，即在当前位置输出括号里的内容
*凡是从页面上进入js的都是字符串类型
8.查找元素：抓住根节点，就等于抓住整棵树
网页的根节点：document对象
要找元素，必须利用document对象（当前网页文件）
精确查找某个ID的元素：document.getElementById(id名)；
9.null和undefined：
|--null：一个特殊的值，表示“无值”--空对象。数据类型为Object
|--undefined：表示声明了变量但从未
赋值
或者对象属性不存在
10.双等号（==）和全等号（===）：
|--“==”为确定两个运算数是否相等，“==”运算符会进行类型转换。转换后运算数相等就返回true，否则返回false
|--“===”不执行类型转换，即，只有在无需类型转换运算数就相等的情况下，才返回true，否则返回false
|--附：if(null)、if(defined)、if(NaN)都相当于if(false)
-----猜数字游戏-----
失去焦点时，判断猜对猜错
获得焦点：onfocus 失去焦点：onblur
当事件就发生在获得内容的当前元素上：
this直接获得当前内容对象。可以代替当前对象完成一切操作，拥有当前对象的所有属性
前端优化：js中最好用三目运算代替if else
11.String：
|--查找：x.indexOf(‘关键字’[，开始位置下标])
| 每次只查找第一次出现的位置
|--替换：x.replace(‘关键字’[,‘替换内容’])--不会修改原x字符串
| 每次只替换第一次找到的
|--查找和替换所有：while循环
|--String 对象的
常
用方法有：
|--x.toLowerCase()、x.toUpperCase()：大小写转换方法；
|--x.charAt(index)：返回指定位置的字符；
|--x.charCodeAt(index)：返回指定位置字符的Unicode编码；
|--x.indexOf(findstr,index)、x.lastIndexOf(findstr,index)： 获取指定字符；
|--x.substring(start, end)： 获取子字符串；
|--x.replace(findstr,tostr)：替换子字符串；
|--x.split(bystr)： 拆分子字符串。
|--String与正则表达式
|--str.match(regExp);--查找str中匹配正则表达式的关键字
| 返回：如果没找到，返回null。若找到，返回1个数组，数组的每个元素是每个找到的匹配关键 | |--str.replace(regExp,"替换值")--替换str中所有匹配的关键字
| 强调：replace方法不改变元字符串，只能返回新字符串。必须用变量接收新字符串
|--js中正则表达式语法：/正则表达式/[属性
后缀
]--其中属性
后缀
，g：全局匹配 i：忽略大小写(仅英文有效)
如果不适用模式匹配方式，将执行原文匹配
结果：如果正则表达式写错，也将执行原文匹配
12.Array笔试题：js中数组声明方式：
A new Array(7)
B new Array(7，‘a’，true)
C [7，'a',true]--js中所有[]都表示数组
D []--实例化一个空数组对象 实例化空数组：var arr=[];
特点：元素个数不限定，元素类型不限制
13.Array 对象的
常
用方法：
|--1.join()方法--用于把数组中的所有元素放入一个字符串
| eparato表示要使用的分隔符。如果省略该参数，则使用逗号作为分隔符
|--2.toString()方法--可把数组转换为字符串，并返回结果
|--3.concat()方法--用于连接两个或多个数组，该方法不会改变现有的数组
|--4.slice()方法--截取元素。根据给定的范围可从已有的数组中返回选定的元素
14.Function：js中一切都是对象，连方法都是1个对象！！
笔试题：js中方法定义集中方式：
A：function compare(a,b){return a-b;}---*可以任意地方声明方法*
B：var compare=function(a,b){return a-b;} ---|
--其实方法名也是方法对象的变量名;等号右边其实就是1个匿名方法对象 |--*必须在传递之前声明方法对象*
C：var compare=new Function('a','b','return a-b') ---|
--其实js底层就是new Function;构造函数中的参数都是字符串
结论：所有的方法都是function类型的。
15.JavaScript中的所有事物都是对象，分为三类：
|--简单对象：String、Number、Boolean
|--组合对象：Array、Math、Date
|--复杂对象：Function、Regex、Object等
16.Array排序：
|--升序：function compare(a,b){return a-b;}
|--降序：function compare(a,b){return b-a;}
比较器用法：arr.sort(比较器方法名);
遍历：for(var i=0;i<arr.length;i++)--等同Java
Array倒转：arr.reverse();用于颠倒数组中元素的顺序
17.Array元素操作：
|--arr.push(x);向数组增
加
1个新元素x（位于数组最后位置）
|--arr.splice(开始位置，删除几个[,x1,x2,x3...])
|--arr.indexOf(x) 返回x在数组中的下标---经
常
用于判断元素是否存在。如返回-1，x则不在数组中
18.Number对象：
|--x.toFixed(num):可把Number四舍五入为指定小数位数(num:0-20)的数字
|--x.toString():用于把一个 Number 对象转换为一个字符串，并返回结果
19.正则表达式对象:(专门用于查找和验证)
reg.test(‘要验证的完整字符串’)匹配返回true，否则返回false
强调：如果正则表达式使用了^和$，必须完整匹配才行。反之则部分匹配
20.Date对象：（计算方法：先get，再计算，最后set回去）
|--1.每个分量上都有一对get/set方法
|--2.命名：get|set年月日，单数；get|set时分秒，复数（s）
|--3.除了日期从1开始到31结束外，其余都从0开始到-1结束
|--Date对象的
常
用方法
|--1.获取日期数据 getDate()、getDay()、getFullYear()等
|--2.修改日期数据 setDate()、setDay()、setFullYear()等
|--3.获取日期格式的字符串 toString()、toLocaleTimeString()、toLocaleDateString()等
21.argument参数：所有方法都隐藏的一个数组对象
作用：不设置任何的形参的情况下，自动接收所有传入参数
arguments.length：获得参数个数
arguments[i]：获得每个参数--都要判断和类型转换
22.全局函数：不用任何对象点(.)就可以调用--可用于所有的 JavaScript 对象
常
用的全局函数有：parseInt/parseFloat、isNaN、eval、decodeURI/encodeURI等。
encodeURI和decodeURI：
|--encodeURI：可把字符串作为 URI 进行编码
|--decodeURI：decodeURI()函数可对encodeURI()函数编码过的 URI 进行解码
eval() 函数可计算某个字符串，并执行其中的的JavaScript代码
23.BOM:操作浏览器窗口的对象模型。
--即浏览器对象模型 ，用来访问和操纵浏览器窗口，使 JavaScript 有能力与浏览器“对话”
DOM：操作网页中元素对象的对象模型--即文档对象模型，用来操作文档
window对象的
常
用属性：
|--document：窗口中显示的 HTML 文档对象
|--history：本次浏览过窗口的历史记录
| --前进：history.go(1);后退：history.go(-1);刷新：history.go(0);
|--location：窗口文件地址对象（地址栏）
|--event：事件对象
|--screen：屏幕对象
|--name：窗口名称
|--opener：打开当前窗口的 window 对象
|--navigator：有关浏览器的信息
|--cookieEnable：判断当前浏览器是否启用cookie
|--userAgent:获得浏览器的名称和版本号
window 对象的
常
用方法有：
|--alert();--警告框--只能点确认
|--confirm();确认框--可以选择确认或取消
|--prompt();对话框--用于显示可提示用户进行输入
|--window.open('url'[,'name'])：打开1个选项卡
|--window.close()：关闭当前选项卡
24.定时器：凡是网页中自动动态的效果都是用计时器实现的
|--周期性定时器：每隔一个时间段自动执行一次，循环执行
| |--setInterval() 启动-->用于启动一个周期性定时器
| 语法：timer=setInterval(方法名，间隔毫秒数)
|--clearInterval() 停止-->用于停止一个周期性定时器
语法：timer=clearInterval(timer)
|--1次性定时器：先等待一段时间，再自动执行一次，自动结束
|--setTimeout() 启动-->用于启动一个一次性定时器
|--clearTimeout() 停止-->用于停止一个一次性定时器
|--表单控件，读写内容：.value
|--普通html元素，要想读写开始标签和结束标签之间的内容：[removed]
计时器：1.做什么事：方法；
2.一个变量：存计时器的线程号
3.何时启动计时器：事件
25.document：1.代表当前网页文档；
2.所有网页元素的根元素；
3.查找和操作元素，都要依靠document；
节点：nodeName--标签名或属性名
DOM操作样式：对象.className属性
等效于<标签class="">
DOM树：当前节点向上：txtObj[removed]（）
向下：txtObj.getElementByTagName（）
26.表单中查找控件对象：document.getElementsByName('name属性')
DOM增
加
新节点：两种方法
创建新节点：document.creatElement('标签名')
--此时新元素对象仅在内存中游离，页面看不见！
添
加
新节点：找到父元素！
|--appendChild() 方法只能将新节点作为某节点的最后一个子节点
| --此时新元素追
加
到了父元素的末尾
|--parentNode.insertBefore()(新元素对象，A)--其中A为新元素要插入位置的后一位元素
DOM删除元素：node.removeChild(childNode)--node为父节点，childNode为要删除的节点
27.HTML DOM
Select和Option对象：
select对象：代表HTML表单中的一个下拉列表，每个<select> 标签即表示一个 Select 对象
|--属性：
|--options：返回包含<select>元素中所有<option>的一个数组，每个元素对应一个<option>标签，索引从0开始
|--selectedIndex：设置或返回下拉列表中被选选项的索引号
|--size：设置或返回下拉列表中一次显示显示的选项数
|--方法：
|--add(option)：用于向<select>添
加
一个<option>元素。
|--remove(index)：从下拉列表删除选项
Select对象有事件onChange当改变选择时调用的事件句柄。Select对象的onChange属性引用了一个事件句柄函数。当用户选
中一个选项，或者取消了对一个选项的选定时，就会调用该句柄。这个事件不会指定新的选项是什么，必须通过Select对象的 selectedIndex属性，或者各个Option对象的selected属性来确定这一点。
option对象：代表HTML表单中下拉列表中的一个选项，每个<option>标签表示一个Option对象
|--创建：var o = new Option(text,value);
|--属性：
|--index：返回下拉列表中选项的索引位置
|--text：设置或返回选项的文本值；
|--value：设置或返回选项的值；
|--selected：设置或返回选项的 selected 属性的值，该属性设置选项的当前状态，如果为 true，则该选项被选中
28.table对象：
rows数组：表中所有行对象
方法：var row=table.iusertRow(i);--返回刚添
加
的新行
table.deleteRow(i); --i：行的下标。如果i取-1，即在表格末尾追
加
一行
tableRow对象：
cells数组：当前行中所有单元格的对象
方法：var 刚添
加
的新单元格=tr.iusertCell(i);
tr.deleteCell(i);
tableCell对象：取单元格内容--td[removed]
29.事件冒泡：
|--1.由外向内，捕获事件：记录哪级元素有什么事件
|--2.由内向外，冒泡执行：按记录的顺序由内向外执行
取消冒泡：
|--1.获得事件对象！--event
onclick="func(event)"--其中event和this都是关键字，表示事件对象
func(e)--此时e就是事件对象
|--2.取消冒泡：e.cancelBubble=true;
何时用：如果大量子元素拥有相同事件，应将相同事件统一定义在1个父元素上1次即可
?存储类型
在本课中，我们只介绍数据类型说明。其它说明在以后各章中陆续介绍。所谓数据类型是按被说明量的性质，表示形式，占据存储空间的多少，构造特点来划分的。在Ｃ语言中，数据类型可分为：基本数据类型，构造数据类型，指针类型，空类型四大类。
1.基本数据类型
基本数据类型最主要的特点是，其值不可以再分解为其它类型。也就是说，基本数据类型是自我说明的。
2.构造数据类型构造数据类型
是根据已定义的一个或多个数据类型用构造的方法来定义的。也就是说，一个构造类型的值可以分解成若干个“成员”或“元素”。每个“成员”都是一个基本数据类型或又是一个构造类型。在C语言中，构造类型有以下几种：
?数组类型
?结构类型
?联合类型
3.指针类型
指针是一种特殊的，同时又是具有重要作用的数据类型。其值用来表示某个量在内存储器中的地址。虽然指针变量的取值类似于整型量，但这是两个类型完全不同的量，因此不能混为一谈。4.空类型在调用函数值时，通
常
应向调用者返回一个函数值。这个返回的函数值是具有一定的数据类型的，应在函数定义及函数说明中给以说明，例如在例题中给出的max函数定义中，函数头为： int max(int a,int b);其中“int ”类型说明符即表示该函数的返回值为整型量。又如在例题中，使用了库函数 sin，由于系统规定其函数返回值为双精度浮点型，因此在
赋值
语句s=sin (x);中，s 也必须是双精度浮点型，以便与sin函数的返回值一致。所以在说明部分，把s说明为双精度浮点型。但是，也有一类函数，调用后并不需要向调用者返回函数值， 这种函数可以定义为“空类型”。其类型说明符为void。在第五章函数中还要详细介绍。在本章中，我们先介绍基本数据类型中的整型、浮点型和字符型。其余类型在以后各章中陆续介绍。
对于基本数据类型量，按其取值是否可改变又分为
常
量和变量两种。在程序执行过程中，其值不发生改变的量称为
常
量，取值可变的量称为变量。它们可与数据类型结合起来分类。例如，可分为整型
常
量、整型变量、浮点
常
量、浮点变量、字符
常
量、字符变量、枚举
常
量、枚举变量。在程序中，
常
量是可以不经说明而直接引用的，而变量则必须先说明后使用。
整型量包括整型
常
量、整型变量。整型
常
量就是整
常
数。在Ｃ语言中，使用的整
常
数有八进制、十六进制和十进制三种。
整型
常
量
1.八进制整
常
数八进制整
常
数必须以0开头，即以0作为八进制数的前缀。数码取值为0～7。八进制数通
常
是无符号数。
以下各数是合法的八进制数：
015(十进制为13) 0101(十进制为65) 0177777(十进制为65535)
以下各数不是合法的八进制数：
256(无前缀0) 03A2(包含了非八进制数码) -0127(出现了负号)
2.十六进制整
常
数
十六进制整
常
数的前缀为0X或0x。其数码取值为0~9，A~F或a~f。
以下各数是合法的十六进制整
常
数：
0X2A(十进制为42) 0XA0 (十进制为160) 0XFFFF (十进制为65535)
以下各数不是合法的十六进制整
常
数：
5A (无前缀0X) 0X3H (含有非十六进制数码)
3.十进制整
常
数
十进制整
常
数没有前缀。其数码为0～9。
以下各数是合法的十进制整
常
数：
237 -568 65535 1627
以下各数不是合法的十进制整
常
数：
023 (不能有前导0) 23D (含有非十进制数码)
在程序中是根据前缀来区分各种进制数的。因此在书写
常
数时不要把前缀弄错造成结果不正确。4.整型
常
数的
后缀
在16位字长的机器上，基本整型的长度也为16位，因此表示的数的范围也是有限定的。十进制无符号整
常
数的范围为0～65535，有符号数为-32768～+32767。八进制无符号数的表示范围为0～0177777。十六进制无符号数的表示范围为0X0～0XFFFF或0x0～0xFFFF。如果使用的数超过了上述范围，就必须用长整型数来表示。长整型数是用
后缀
“L”或“l”来表示的。例如：
十进制长整
常
数 158L (十进制为158) 358000L (十进制为-358000)
八进制长整
常
数 012L (十进制为10) 077L (十进制为63) 0200000L (十进制为65536)
十六进制长整
常
数 0X15L (十进制为21) 0XA5L (十进制为165) 0X10000L (十进制为65536)
长整数158L和基本整
常
数158 在数值上并无
区别
。但对158L，因为是长整型量，Ｃ编译系统将为它分配4个字节存储空间。而对158，因为是基本整型，只分配2 个字节的存储空间。因此在运算和输出格式上要予以注意，避免出错。无符号数也可用
后缀
表示，整型
常
数的无符号数的
后缀
为“U”或“u”。例如： 358u,0x38Au,235Lu 均为无符号数。前缀，
后缀
可同时使用以表示各种类型的数。如0XA5Lu表示十六进制无符号长整数A5，其十进制为165。
整型变量可分为以下几类：
1.基本型
类型说明符为int，在内存中占2个字节，其取值为基本整
常
数。
2.短整量
类型说明符为short int或short'C110F1。所占字节和取值范围均与基本型相同。
3.长整型
类型说明符为long int或long ，在内存中占4个字节，其取值为长整
常
数。
4.无符号型
类型说明符为unsigned。
无符号型又可与上述三种类型匹配而构成：
(1)无符号基本型 类型说明符为unsigned int或unsigned。
(2)无符号短整型 类型说明符为unsigned short
(3)无符号长整型 类型说明符为unsigned long
各种无符号类型量所占的内存空间字节数与相应的有符号类型量相同。但由于省去了符号位，故不能表示负数。 下表列出了Turbo C中各类整型量所分配的内存字节数及数的表示范围。
类型说明符 数的范围 分配字节数
int -32768~32767 ■■
short int -32768~32767 ■■
signed int -32768~32767 ■■
unsigned int 0~65535 ■■
long int -2147483648~2147483647 ■■■■
unsigned long 0~4294967295 ■■■■
整型变量的说明
变量说明的一般形式为： 类型说明符 变量名标识符，变量名标识符，...; 例如：
int a,b,c; (a,b,c为整型变量)
long x,y; (x,y为长整型变量)
unsigned p,q; (p,q为无符号整型变量)
在书写变量说明时，应注意以下几点：
1.允许在一个类型说明符后，说明多个相同类型的变量。各变量名之间用逗号间隔。类型说明符与变量名之间至少用一个空格间隔。
2.最后一个变量名之后必须以“；”号结尾。
3.变量说明必须放在变量使用之前。一般放在函数体的开头部分。
[Practice] //1int a,b;
short int c;
short d=100;
a=d-20;
b=a+d;
c=a+b+d;
d=d-a+c-b;'Vtable
a,2,0
b,2,0
c,2,0
d,2,100
of Vtable
'Vupdate
1,0;2,0
4,100
2,180
3,360
4,200
of Vupdate
of Practice
[Practice] //2int a=5;
int b=9;
long int c;
long d;
c=a+b-7;
d=a*b*c;
c=d*d*d;
a=c-d;'Vtable
a,2,5
b,2,9
c,4,0
d,4,0
of Vtable
'Vupdate
4,315
3,31255875
1,-5112
of Vupdate
of Practice
[Practice] //3int a=6,b=19;
unsigned int c;
int d;
c=a-b+7;
d=b*c;
a=b+c+d;
b=-a;'Vtable
a,2,6
b,2,19
c,2,0
d,2,0
of Vtable
'Vupdate
1,6;2,19
3,65530
4,-114
1,-101
2,101
of Vupdate
of Practice
void main(){
long x,y;
int a,b,c,d;
c=x+a;
d=y+b;
printf("c=x+a=%d,d=y+b=%d\n",c,d);
将main说明为返回void,即不返回任何类型的值
x,y被定义为long型
a,b,c,d被定义为int型
x+a->c
y+b->d
显示程序运行结果 of long x,y;
int a,b,c,d;
c=x+a;
d=y+b;
从程序中可以看到：x, y是长整型变量，a, b是基本整型变量。它们之间允许进行运算，运算结果为长整型。但c，d被定义为基本整型，因此最后结果为基本整型。本例说明，不同类型的量可以参与运算并相互
赋值
。其中的类型转换是由编译系统自动完成的。有关类型转换的规则将在以后介绍。
实型
常
量
实型也称为浮点型。实型
常
量也称为实数或者
浮点数
。在Ｃ语言中，实数只采用十进制。它有二种形式： 十进制数形式指数形式
1.十进制数形式
由数码0~ 9和小数点组成。例如：0.0，.25，5.789，0.13，5.0，300.，-267.8230等均为合法的实数。
2.指数形式
由十进制数，
加
阶码标志“e”或“E”以及阶码（只能为整数，可以带符号）组成。其一般形式为a E n （a为十进制数，n为十进制整数）其值为 a*10,n 如： 2.1E5 (等于2.1*10,5), 3.7E-2 (等于3.7*10,)-2*) 0.5E7 (等于0.5*10,7), -2.8E-2 (等于-2.8*10,)-2*)以下不是合法的实数 345 (无小数点) E7 (阶码标志E之前无数字) -5 (无阶码标志) 53.-E3 (负号位置不对) 2.7E (无阶码)
标准Ｃ允许
浮点数
使用
后缀
。
后缀
为“f”或“F”即表示该数为
浮点数
。如356f和356.是等价的。例2.2说明了这种情况：
void main()
printf("%f\n%f\n",356.,356f);
void 指明main不返回任何值 利用printf显示结果 结束
实型变量分为两类：单精度型和双精度型，
其类型说明符为float 单精度说明符，double 双精度说明符。在Turbo C中单精度型占4个字节（32位）内存空间，其数值范围为3.4E-38～3.4E+38，只能提供七位有效数字。双精度型占8 个字节（64位）内存空间，其数值范围为1.7E-308～1.7E+308，可提供16位有效数字。
实型变量说明的格式和书写规则与整型相同。
例如： float x,y; (x,y为单精度实型量)
double a,b,c; (a,b,c为双精度实型量)
实型
常
数不分单、双精度，都按双精度double型处理。
void main()
float a;
double b;
a=33333.33333;
b=33333.33333333333333;
printf("%f\n%f\n",a,b);
此程序说明float、double的不同
a ■■■■
b ■■■■■■■■
a<---33333.33333
b<---33333.33333333333;;
显示程序结果
此程序说明float、double的不同
float a;
double b;
a=33333.33333;
b=33333.33333333333333; 从本例可以看出，由于a 是单精度浮点型，有效位数只有七位。而整数已占五位，故小数二位后之后均为无效数字。b 是双精度型，有效位为十六位。但Turbo C 规定小数后最多保留六位，其余部分四舍五入。
[Practice] //floatint a=32;
float b;
double d;
b=12345678;
d=b*100;
d=d+a;
d=d+58.123456;'Vtable
a,2,32
b,4,0.0
d,8,0.0
of Vtable
'Vupdate
2,12345678.00000
3,1234567800
3,1234567832
3,1234567890.123456
of Vupdate
of Practice
[Practice] //1int a=543;
float b;
b=123.123962+a;
b=b-100;
a=b;'Vtable
a,2,543
b,4,0.0
of Vtable
'Vupdate
1,543
2,0.0
2,123.123962
2,23.123962
of Vupdate
of Practice
字符型量包括字符
常
量和字符变量。
字符
常
量
字符
常
量是用单引号括起来的一个字符。例如'a','b','=','+','?'都是合法字符
常
量。在Ｃ语言中，字符
常
量有以下特点：
1.字符
常
量只能用单引号括起来，不能用双引号或其它括号。
2.字符
常
量只能是单个字符，不能是字符串。
3.字符可以是字符集中任意字符。但数字被定义为字符型之后就
不能参与数值运算。如'5'和5 是不同的。'5'是字符
常
量，不能参与运算。
转义字符是一种特殊的字符
常
量。转义字符以反斜线"\"开头，后跟一个或几个字符。转义字符具有特定的含义，不同于字符原有的意义，故称“转义”字符。例如，在前面各例题printf函数的格式串中用到的“\n”就是一个转义字符，其意义是“回车换行”。转义字符主要用来表示那些用一般字符不便于表示的控制代码。
常
用的转义字符及其含义
转义字符 转义字符的意义
\n 回车换行
\t 横向跳到下一制表位置
\v 竖向跳格
\b 退格
\r 回车
\f 走纸换页
\\ 反斜线符"\"
\' 单引号符
\a 鸣铃
\ddd 1～3位八进制数所代表的字符
\xhh 1～2位十六进制数所代表的字符
广义地讲，Ｃ语言字符集中的任何一个字符均可用转义字符来表示。表2.2中的\ddd和\xhh正是为此而提出的。ddd和hh分别为八进制和十六进制的ASCII代码。如\101表示字?quot;A" ，\102表示字母"B"，\134表示反斜线，\XOA表示换行等。转义字符的使用
void main()
int a,b,c;
a=5; b=6; c=7;
printf("%d\n\t%d %d\n %d %d\t\b%d\n",a,b,c,a,b,c);
此程序练习转义字符的使用
a、b、c为整数 5->a,6->b,7->c
调用printf显示程序运行结果
printf("%d\n\t%d %d\n %d %d\t\b%d\n",a,b,c,a,b,c);
程序在第一列输出a值5之后就是“\n”，故回车换行；接着又是“\t”，于是跳到下一制表位置（设制表位置间隔为8），再输出b值6；空二格再输出c 值7后又是"\n"，因此再回车换行；再空二格之后又输出a值5；再空三格又输出b的值6；再次后"\t"跳到下一制表位置（与上一行的6 对齐），但下一转义字符“\b”又使退回一格，故紧挨着6再输出c值7。
字符变量的取值是字符
常
量，即单个字符。字符变量的类型说明符是char。字符变量类型说明的格式和书写规则都与整型变量相同。
char a,b; 每个字符变量被分配一个字节的内存空间，因此只能存放一个字符。字符值是以ASCII码的形式存放在变量的内存单元之中的。如x的
十进制ASCII码是120，y的十进制ASCII码是121。对字符变量a,b赋予'x'和'y'值： a='x';b='y';实际上是在a,b两个单元内存放120和121的二进制代码： a 0 1 1 1 1 0 0 0
b 0 1 1 1 1 0 0 1
所以也可以把它们看成是整型量。 Ｃ语言允许对整型变量赋以字符值，也允许对字符变量赋以整型值。在输出时， 允许把字符变量按整型量输出，也允许把整型量按字符量输出。 整型量为二字节量，字符量为单字节量，当整型量按字符型量处理时， 只有低八位字节参与处理。
main()
char a,b;
a=120;
b=121;
printf("%c,%c\n%d,%d\n",a,b,a,b);
a ■ b ■
a <-- 120
b <--- 121
显示程序结果
本程序中说明a，b为字符型，但在
赋值
语句中赋以整型值。从结果看，a，b值的输出形式取决于printf函数格式串中的格式符，当格式符为"c"时，对应输出的变量值为字符，当格式符为"d"时，对应输出的变量值为整数。
void main()
char a,b;
a='x';
b='y';
a=a-32;
b=b-32;
printf("%c,%c\n%d,%d\n",a,b,a,b);
a，b被说明为字符变量并赋予字符值
把小写字母换成大写字母
以整型和字符型输出
本例中，a，b被说明为字符变量并赋予字符值，Ｃ语言允许字符变量参与数值运算，即用字符的ASCII 码参与运算。由于大小写字母的ASCII 码相差32，因此运算后把小写字母换成大写字母。然后分别以整型和字符型输出。
[Practice] //charint a=49;
char b;
char d;
b=a+10;
d=a+b;'Vtable
a,2,49
b,1,随机
d,1,随机
of Vtable
'Vupdate
2,';'
3,'l'
of Vupdate
of Practice
[Practice] //char c1,c2;
c1='a';c2='b';
c1=c1-32;c2=c2-32;'Vtable
c1,1,随机
c2,1,随机
of Vtable
'Vupdate
1,随机;2,随机
1,'a';2,'b'
1,'A';2,'B'
of Vupdate
of Practice
字符串
常
量
字符串
常
量是由一对双引号括起的字符序列。例如： "CHINA" ，"C program:" ， "$12.5" 等都是合法的字符串
常
量。字符串
常
量和字符
常
量是不同的量。它们之间主要有以下
区别
：
1.字符
常
量由单引号括起来，字符串
常
量由双引号括起来。
2.字符
常
量只能是单个字符，字符串
常
量则可以含一个或多个字符。
3.可以把一个字符
常
量赋予一个字符变量，但不能把一个字符串
常
量赋予一个字符变量。在Ｃ语言中没有相应的字符串变量。
这是与BASIC 语言不同的。但是可以用一个字符数组来存放一个字符串
常
量。在数组一章内予以介绍。
4.字符
常
量占一个字节的内存空间。字符串
常
量占的内存字节数等于字符串中字节数
加
1。增
加
的一个字节中存放字符"\0"(ASCII码为0)。这是字符串结束的标志。例如，字符串 "C program"在内存中所占的字节为：C program\0。字符
常
量'a'和字符串
常
量"a"虽然都只有一个字符，但在内存中的情况是不同的。
'a'在内存中占一个字节，可表示为：a
"a"在内存中占二个字节，可表示为：a\0符号
常
量
符号
常
量
在Ｃ语言中，可以用一个标识符来表示一个
常
量，称之为符号
常
量。符号
常
量在使用之前必须先定义，其一般形式为：
#define 标识符
常
量
其中#define也是一条预处理命令（预处理命令都?quot;#"开头），称为宏定义命令（在第九章预处理程序中将进一步介绍），其功能是把该标识符定义为其后的
常
量值。一经定义，以后在程序中所有出现该标识符的地方均代之以该
常
量值。习惯上符号
常
量的标识符用大写字母，变量标识符用小写字母，以示
区别
。
#define PI 3.14159
void main()
float s,r;
s=PI*r*r;
printf("s=%f\n",s);
由宏定义命令定义PI 为3.14159 s,r定义为实数 5->r PI*r*r->s
显示程序结果 float s,r; r=5; s=PI*r*r; 本程序在主函数之前由宏定义命令定义PI 为3.14159，在程序中即以该值代替PI 。s=PI*r*r等效于s=3.14159*r*r。应该注意的是，符号
常
量不是变量，它所代表的值在整个作用域内不能再改变。也就是说，在程序中，不能再用
赋值
语句对它重新
赋值
。
变量的初值和类型转换
变量赋初值
在程序中
常
常
需要对变量赋初值，以便使用变量。语言程序中可有多种方法，在定义时赋以初值的方法，这种方法称为初始化。在变量说明中赋初值的一般形式为：
类型说明符 变量1= 值1，变量2= 值2，……； 例如：
int a=b=c=5;
float x=3.2,y=3f,z=0.75;
char ch1='K',ch2='P';
应注意，在说明中不允许连续
赋值
，如a=b=c=5是不合法的。
void main()
int a=3,b,c=5;
b=a+c;
printf("a=%d,b=%d,c=%d\n",a,b,c);
a<---3,b<--0,c<---5
b<--a+c
显示程序运行结果
变量类型的转换
变量的数据类型是可以转换的。转换的方法有两种， 一种是自动转换，一种是强制转换。
自动转换发生在不同数据类型的量混合运算时，由编译系统自动完成。自动转换遵循以下规则：
1.若参与运算量的类型不同，则先转换成同一类型，然后进行运算。
2.转换按数据长度增
加
的方向进行，以保证精度不降低。如int型和long型运算时，先把int量转成long型后再进行运算。
3.所有的浮点运算都是以双精度进行的，即使仅含float单精度量运算的表达式，也要先转换成double型，再作运算。
4.char型和short型参与运算时，必须先转换成int型。
5.在
赋值
运算中，
赋值
号两边量的数据类型不同时，
赋值
号右边量的类型将转换为左边量的类型。 如果右边量的数据类型长度左边长时，将丢失一部分数据，这样会降低精度， 丢失的部分按四舍五入向前舍入。图21表示了类型自动转换的规则。
void main()
float PI=3.14159;
int s,r=5;
s=r*r*PI;
printf("s=%d\n",s);
PI<--3.14159
s<--0,r<--5
s<--r*r*PI
显示程序运行结果
float PI=3.14159;
int s,r=5;
s=r*r*PI;
本例程序中，PI为实型；s，r为整型。在执行s=r*r*PI语句时，r和PI都转换成double型计算，结果也为double型。但由于s为整型，故
赋值
结果仍为整型，舍去了小数部分。
强制类型转换
强制类型转换是通过类型转换运算来实现的。其一般形式为： (类型说明符) (表达式) 其功能是把表达式的运算结果强制转换成类型说明符所表示的类型。例如： (float) a 把a转换为实型(int)(x+y) 把x+y的结果转换为整型在使用强制转换时应注意以下问题：
1.类型说明符和表达式都必须
加
括号(单个变量可以
不加
括号)，如把(int)(x+y)写成(int)x+y则成了把x转换成int型之后再与y相
加
了。
2.无论是强制转换或是自动转换，都只是为了本次运算的需要而对变量的数据长度进行的临时性转换，而不改变数据说明时对该变量定义的类型。
main()
float f=5.75;
printf("(int)f=%d,f=%f\n",(int)f,f);
f<--5.75
将float f强制转换成int f float f=5.75;printf("(int)f=%d,f=%f\n",(int)f,f); 本例表明，f虽强制转为int型，但只在运算中起作用， 是临时的，而f本身的类型并不改变。因此，(int)f的值为 5(删去了小数)而f的值仍为5.75。
基本运算符和表达式
运算符的种类、优先级和结合性
Ｃ语言中运算符和表达式数量之多， 在高级语言中是少见的。正是丰富的运算符和表达式使Ｃ语言功能十分完善。 这也是Ｃ语言的主要特点之一。
Ｃ语言的运算符不仅具有不同的优先级， 而且还有一个特点，就是它的结合性。在表达式中， 各运算量参与运算的先后顺序不仅要遵守运算符优先级别的规定，还要受运算符结合性的制约， 以便确定是自左向右进行运算还是自右向左进行运算。 这种结合性是其它高级语言的运算符所没有的，因此也增
加
了Ｃ语言的复杂性。
运算符的种类Ｃ语言的运算符可分为以下几类：
1.算术运算符
用于各类数值运算。包括
加
(+)、减(-)、乘(*)、除(/)、求余(或称模运算，%)、自增(++)、自减(--)共七种。
2.关系运算符
用于比较运算。包括大于(>)、小于(<)、等于(==)、 大于等于(>=)、小于等于(<=)和不等于(!=)六种。
3.逻辑运算符
用于逻辑运算。包括与(&&)、或(||)、非(!)三种。
4.位操作运算符
参与运算的量，按二进制位进行运算。包括位与(&)、位或(|)、位非(~)、位异或(^)、左移(<<)、右移(>>)六种。
5.
赋值
运算符
用于
赋值
运算，分为简单
赋值
(=)、复合算术
赋值
(+=,-=,*=,/=,%=)和复合位运算
赋值
(&=,|=,^=,>>=,<<=)三类共十一种。
6.条件运算符
这是一个三目运算符，用于条件求值(?:)。
7.逗号运算符
用于把若干表达式组合成一个表达式(，)。
8.指针运算符
用于取内容(*)和取地址(&)二种运算。
9.求字节数运算符
用于计算数据类型所占的字节数(sizeof)。
10.特殊运算符
有括号()，下标[]，成员(→，.)等几种。
优先级和结合性
Ｃ语言中，运算符的运算优先级共分为15级。1级最高，15级最低。在表达式中，优先级较高的先于优先级较低的进行运算。 而在一个运算量两侧的运算符优先级相同时， 则按运算符的结合性所规定的结合方向处理。 Ｃ语言中各运算符的结合性分为两种，即左结合性(自左至右)和右结合性(自右至左)。例如算术运算符的结合性是自左至右，即先左后右。如有表达式x-y+z则y应先与“-”号结合， 执行x-y运算，然后再执行+z的运算。这种自左至右的结合方向就称为“左结合性”。而自右至左的结合方向称为“右结合性”。 最典型的右结合性运算符是
赋值
运算符。如x=y=z,由于“=”的右结合性，应先执行y=z再执行x=(y=z)运算。 Ｃ语言运算符中有不少为右结合性，应注意
区别
，以避免理解错误。
算术运算符和算术表达式基本的算术运算符
1.
加
法运算符“+”
加
法运算符为双目运算符，即应有两个量参与
加
法运算。如a+b,4+8等。具有右结合性。
2.减法运算符“-”减法运算符为双目运算符。但“-”也可作负值运算符，此时为单目运算，如-x,-5等具有左结合性。
3.乘法运算符“*”双目运算，具有左结合性。
4.除法运算符“/”双目运算具有左结合性。参与运算量均为整型时， 结果也为整型，舍去小数。如果运算量中有一个是实型，则结果为双精度实型。
void main(){
printf("\n\n%d,%d\n",20/7,-20/7);
printf("%f,%f\n",20.0/7,-20.0/7);
双目运算具有左结合性。参与运算量均为整型时， 结果也为整型，舍去小数。如果运算量中有一个是实型，则结果为双精度实型。 printf("\n\n%d,%d\n",20/7,-20/7);
printf("%f,%f\n",20.0/7,-20.0/7);
本例中，20/7，-20/7的结果均为整型，小数全部舍去。而20.0/7和-20.0/7由于有实数参与运算，因此结果也为实型。
5.求余运算符(模运算符)“%”双目运算，具有左结合性。要求参与运算的量均为整型。 求余运算的结果等于两数相除后的余数。
void main(){
printf("%d\n",100%3);
双目运算，具有左结合性。求余运算符% 要求参与运算的量均为整型。本例输出100除以3所得的余数1。
自增１，自减１运算符
自增1运算符记为“++”，其功能是使变量的值自增1。自减1运算符记为“--”，其功能是使变量值自减1。自增1，自减1运算符均为单目运算，都具有右结合性。可有以下几种形式： ++i i自增1后再参与其它运算。--i i自减1后再参与其它运算。
i++ i参与运算后，i的值再自增1。
i-- i参与运算后，i的值再自减1。
在理解和使用上容易出错的是i++和i--。 特别是当它们出在较复杂的表达式或语句中时，
常
常
难于弄清，因此应仔细分析。
void main(){
int i=8;
printf("%d\n",++i);
printf("%d\n",--i);
printf("%d\n",i++);
printf("%d\n",i--);
printf("%d\n",-i++);
printf("%d\n",-i--);
} i<--8
i<--i+1
i<--i-1
i<--i+1
i<--i-1
i<--i+1
i<--i-1 int i=8;
printf("%d\n",++i);
printf("%d\n",--i);
printf("%d\n",i++);
printf("%d\n",i--);
printf("%d\n",-i++);
printf("%d\n",-i--);
i的初值为8
第2行i
加
1后输出故为9；
第3行减1后输出故为8；
第4行输出i为8之后再
加
1(为9)；
第5行输出i为9之后再减1(为8) ；
第6行输出-8之后再
加
1(为9)；
第7行输出-9之后再减1(为8)
void main(){
int i=5,j=5,p,q;
p=(i++)+(i++)+(i++);
q=(++j)+(++j)+(++j);
printf("%d,%d,%d,%d",p,q,i,j);
i<--5,j<--5,p<--0,q<--0
i+i+i--->p,i+1-->i,i+1-->i,i+1-->i
j+1->j,j+1->j,j+1->j,j+j+j->q int i=5,j=5,p,q;
p=(i++)+(i++)+(i++);
q=(++j)+(++j)+(++j);
这个程序中，对P=(i++)+(i++)+(i++)应理解为三个i相
加
，故P值为15。然后i再自增1三次相当于
加
3故i的最后值为8。而对于q 的值则不然，q=(++j)+(++j)+(++j)应理解为q先自增1，再参与运算，由于q自增1三次后值为8，三个8相
加
的和为24，j的最后值仍为8。算术表达式表达式是由
常
量、变量、函数和运算符组合起来的式子。 一个表达式有一个值及其类型， 它们等于计算表达式所得结果的值和类型。表达式求值按运算符的优先级和结合性规定的顺序进行。 单个的
常
量、变量、函数可以看作是表达式的特例。
算术表达式
是由算术运算符和括号连接起来的式子， 以下是算术表达式的例子：
a+b (a*2)／c (x+r)*8-(a+b)／7 ++i sin(x)+sin(y) (++i)-(j++)+(k--)
赋值
运算符和
赋值
表达式
简单
赋值
运算符和表达式，简单
赋值
运算符记为“=”。由“= ”连接的式子称为
赋值
表达式。其一般形式为： 变量=表达式 例如：
x=a+b
w=sin(a)+sin(b)
y=i+++--j
赋值
表达式的功能是计算表达式的值再赋予左边的变量。
赋值
运算符具有右结合性。因此
a=b=c=5
a=(b=(c=5))
在其它高级语言中，
赋值
构成了一个语句，称为
赋值
语句。 而在C中，把“=”定义为运算符，从而组成
赋值
表达式。 凡是表达式可以出现的地方均可出现
赋值
表达式。例如，式子x=(a=5)+(b=8)是合法的。它的意义是把5赋予a，8赋予b，再把a,b相
加
，和赋予x ，故x应等于13。
在Ｃ语言中也可以组成
赋值
语句，按照Ｃ语言规定， 任何表达式在其未尾
加
上分号就构成为语句。因此如x=8;a=b=c=5；都是
赋值
语句，在前面各例中我们已大量使用过了。
如果
赋值
运算符两边的数据类型不相同， 系统将自动进行类型转换，即把
赋值
号右边的类型换成左边的类型。具体规定如下：
1.实型赋予整型，舍去小数部分。前面的例2.9已经说明了这种情况。
2.整型赋予实型，数值不变，但将以浮点形式存放， 即增
加
小数部分(小数部分的值为0)。
3.字符型赋予整型，由于字符型为一个字节， 而整型为二个字节，故将字符的ASCII码值放到整型量的低八位中，高八位为0。
4.整型赋予字符型，只把低八位赋予字符量。
void main(){
int a,b=322;
float x,y=8.88;
char c1='k',c2;
a=c1;
c2=b;
printf("%d,%f,%d,%c",a,x,a,c2);
int a,b=322;
float x,y=8.88;
char c1='k',c2;
printf("%d,%f,%d,%c",a=y,x=b,a=c1,c2=b);
本例表明了上述
赋值
运算中类型转换的规则。a为整型，赋予实型量y值888后只取整数8。x为实型，赋予整型量b值322， 后增
加
了小数部分。字符型量c1赋予a变为整型，整型量b赋予c2 后取其低八位成为字符型(b的低八位为01000010，即十进制66，按ASCII码对应于字符B)。
复合
赋值
符及表达式
在
赋值
符“=”之前
加
上其它二目运算符可构成复合
赋值
符。如
+=,-=,*=,／=,%=,<<=,>>=,&=,^=,|=。 构成复合
赋值
表达式的一般形式为： 变量 双目运算符=表达式 它等效于 变量=变量 运算符 表达式 例如： a+=5 等价于a=a+5 x*=y+7 等价于x=x*(y+7) r%=p 等价于r=r%p
复合
赋值
符这种写法，对初学者可能不习惯， 但十分有利于编译处理，能提高编译效率并产生质量较高的目标代码。逗号运算符和逗号表达式在
逗号运算符
Ｃ语言中逗号“，”也是一种运算符，称为逗号运算符。 其功能是把两个表达式连接起来组成一个表达式， 称为逗号表达式。
其一般形式为： 表达式1，表达式2 其求值过程是分别求两个表达式的值，并以表达式2的值作为整个逗号表达式的值。
void main(){
int a=2,b=4,c=6,x,y;
x=a+b,y=b+c;
printf("y=%d,x=%d",y,x);
a<--2,b<--4,c<--6,x<--0,y<--0
x<--a+b,y<---b+c
本例中，y等于整个逗号表达式的值，也就是表达式2的值，x是第一个表达式的值。对于逗号表达式还要说明两点：
1.逗号表达式一般形式中的表达式1和表达式2 也可以又是逗号表达式。例如： 表达式1，(表达式2，表达式3) 形成了嵌套情形。因此可以把逗号表达式扩展为以下形式： 表达式1，表达式2，…表达式n 整个逗号表达式的值等于表达式n的值。
2.程序中使用逗号表达式，通
常
是要分别求逗号表达式内各表达式的值，并不一定要求整个逗号表达式的值。
3.并不是在所有出现逗号的地方都组成逗号表达式，如在变量说明中，函数参数表中逗号只是用作各变量之间的间隔符。
[Practice] //arithmeticint a,b,c;
float d;
a=11;
b=235;
c=a+b-a*b;
d=(float)c/(float)a;
a=c/a;'Vtable
a,2,0
b,2,0
c,2,0
d,4,0.0
of Vtable
'Vupdate
1,0;2,0;3,0
4,0.0
2,235
3,-2339
4,-212.636368
1,-212
of Vupdate
of Practice
[Practice] //1int a,b,c1,c2;
a=25;
b=3243;
c1=b/a;
c2=b%a;'Vtable
a,2,0
b,2,0
c1,2,0
c2,2,0
of Vtable
'Vupdate
1,0;2,0;3,0;4,0
2,3243
3,129
of Vupdate
of Practice
[Practice] //1int a,b,c;
a=25;
b=40;
c=a+b,c+35;'Vtable
a,2,0
b,2,0
c,2,0
of Vtable
'Vupdate
1,0;2,0;3,0
of Vupdate
of Practice
1.Ｃ的数据类型
基本类型，构造类型，指针类型，空类型
2.基本类型的分类及特点
类型说明符 字节 数值范围
字符型char 1 C字符集
基本整型int 2 -32768～32767
短整型short int 2 -32768～32767
长整型 long int 4 -214783648～214783647
无符号型 unsigned 2 0～65535
无符号长整型 unsigned long 4 0～4294967295
单精度实型 float 4 3/4E-38～3/4E+38
双精度实型 double 8 1/7E-308～1/7E+308
3.
常
量
后缀
L或l 长整型
U或u 无符号数
F或f
浮点数
4.
常
量类型
整数，长整数，无符号数，
浮点数
，字符，字符串，符号
常
数，转义字符。
5.数据类型转换
?自动转换
在不同类型数据的混合运算中，由系统自动实现转换， 由少字节类型向多字节类型转换。 不同类型的量相互
赋值
时也由系统自动进行转换，把
赋值
号右边的类型转换为左边的类型。
?强制转换
由强制转换运算符完成转换。
6.运算符优先级和结合性
一般而言，单目运算符优先级较高，
赋值
运算符优先级低。 算术运算符优先级较高，关系和逻辑运算符优先级较低。 多数运算符具有左结合性，单目运算符、三目运算符、
赋值
7.表达式
表达式是由运算符连接
常
量、变量、函数所组成的式子。 每个表达式都有一个值和类型。 表达式求值按运算符的优先级和结合性所规定的顺序进行。
程序标准教程
integer number too large
1.float类型末尾
加
f是因为：例如 float f = 4.0f ，4.0是
浮点数
，默认是double类型，如果
不加
f去标记的话，那这个
浮点数
就是从doub
2018 / 12 / 15
arm_matrix_instance_f32 pSrcA; //声明矩阵
arm_mat_init_f32(&pSrcA, 3, 3, pData); //初始化矩阵
arm_mat_add_f32(&pSrc...
基本形式：符号整数部分，小数部分和E指数部分。首先写整数部分（可以带符号），接着写小数部分，然后写 e或者 E，最后再写一个有符号整数。
小数形式是由数字和小数点组成的一种实数表示形式，例如0.123、.123、123.、0.0等都是合法的实型
常
量。注意：小数形式表示的实型
常
量必须要有小数点。
指数形式就是在数学中，一个可以用幂的形式来表示的形式。在C语言中，则以“e”或“...
在C语言中，如果一个
浮点数
的值不以"f"结尾，那么它将被默认为double类型。因此，如果要将一个double类型的值赋给一个float类型的变量，则需要进行类型转换。
float类型又被称作单精度类型，尾数可以精确到7位有效数字，在很多情况下，float类型的精度很难满足需求。而double表示这种类型的数值精度约是float类型的两倍(15位)，又被称作双精度类型，绝大部分应用程序都采用double类型。
float类型的数值有一个
后缀
F或者f ，没有
后缀
F/f的
浮点数
值默认为double类型。也可以在
浮点数
值后添
加
后缀
D或者d， 以明确其为double类型。
（1）浮点
常
量默认为double。要变为flo..
默认的浮点字面值
常
量为 double 类型。在数值的
后面
加
上 F 或 f 表示单精度。同样
加
上 L 或者 l 表示扩展精度(再次提醒, 不提倡使用小写字母 l)。
通
常
可以用十进制或者科学计数法来表示浮点字面值
常
量。使用科学计数法 时,指数用 E 或者 e 表示。
下面每一组字面值表示相同的值:
3.14159F .001f 12.345L 0.
3.14159E0f 1E-3F 1.2345E1L
