#include #include #include #include 定义了一组常量,用来限定编译器complier运行的这台机器的整型数据类型的取值范围
#include
// 001-010 ---> 001-010+1000 = -001+1000 = 1000 - 001(得到001的2补数)= 111
// 111求-001这个正确结果: 先求10补数-->001,再加上负号-001。。。OK!打完收工
// B.m为负数,n为正数,因为n为负数的话,-(-n)=+n就没有讨论的意义了,:(20200101补充)
// 举例: -4-2=-6 --> 6+8 = (10-4)+(10-2) = (-4-2)+10+10 = 4 + 10
// 减去10--十补数之和(模除10效果一样)后再求十补数加负号才得到正确结果
// -001-001 --> 111+111=1110 1110-1000(1110 mod 1000)=110 110十补数=010 --加负号-> -010 (十进制-2)
//
// *处理器提供了一套它能支持的运算操作集合,称为指令集.
// 输入程序和数据:1+2 --> 计算机中:001+010=011 -->输出:3
// 输入程序和数据:7+7 --> 计算机中(设w=3):111+111=1(110) -->110-->输出:6 (溢出)
// |--->计算机 数据+指令得到的数据,映射到什么值与它无关
//
// additive inverse:加法逆元(或称相反数),对于任意一个数n,n和其加法逆元之和为加法单位元(即为零)
// 例如: 7的加法逆元为-7,-0.5的加法逆元为0.5
// -(-x)为什么等于x:x+(-x)=0=(-x)+x,-x为x的加法逆元,x也是-x的加法逆元,-(-x)为-x的加法逆元等于x
// x加上它的相反数-x等于0,-x加上它的相反数-(-x)等于0,因此-(-x)=x
// 加法单位元:在加法运算的集合中,加法单元位加上集合内的任何一个数x,和都会等于这个数x.
// 例如: x+0=x=0+x
// 乘法逆元:在实数范围内, x * 1/x =1,x和1/x互为乘法逆元(x不可能为0,因为1/0无意义),乘法单位元为1.
// x * 1/x = 1;
// -x * -1/x = 1;
//
//20191214暂时小结
// (以这个小结的为准,
// 之前的笔记因为个人理解不到位,还有国内课程教材真的不行啊...
// 英文原版>国内翻译>国内教材。。。
// 以看了国外书籍后的理解为准,毕竟这玩意别人才是原创...):
//
// 位向量(bit vector) --(函数function)[映射map]--> 真值 (位向量和真值一一对应,唯一性)
//
// sign magnitude(符号+大小,国内所谓的原码,这翻译不直观):
// 真值encode成sign magnitude--映射-->位向量,反之,位向量=sign magnitude--[映射]-->真值
//
// one's complement(国内译反码现在的机器基本都用two's complement了,这里就不展开了,理解什么是9补数和1补数就行了)
//
// two's complement(二补数,国内译补码):
// 真值encode成two's complement--映射-->位向量,反之,位向量=two's complement--[映射]-->真值
// two's complement 001和111互为二补数,分别映射有符号整数1和-1
//
// two's complemnt的加减法,本质就是位向量的模运算(详情阅读上面模运算的笔记)
// 二补数(补码)的运算结果正确,是位向量模运算后的余数映射到的真值结果与真值运算的结果相同,
// 当然前提是参与运算的数和结果要在补码映射的范围内,不然发生溢出,结果错误
//
//===================================================================================
//20191222 继续啃《深入理解计算机系统第三版》 P60 整数运算
// 无符号数加法(unsigned addition):----------------------------------------------------------start
// 取值范围: 0 <= x,y < 2^w
// w位无符号数加法运算: 0 <= x+y < 2^w + 2^w
// 0 <= x+y < 2 * 2^w
// 0 <= x+y < 2^w+1 其实x+y实际小于2^w -1,因为x+y最大只能到2^w -2
//
// 假设w=3 0 <= x,y < 2^w --> 0 <= x,y < 2^3 --> 0 <= x,y < 8
// 0 <= x+y < 2^3 + 2^3 -1 = 2*2^3 -1 = 2*8-1 --> x,y取最大值, 7+7 < 15
// or = 2^(3+1) -1 = 2^4 -1
// 二进制表示: x_max + y_max =111+111=1110 < 10000(d:2^w+1=2^3+1) -1=1111
//
// *无符号加法的核心知识点,无符号数加法的溢出检测:
// s=x+y >= x,则没有溢出
// 如果结果溢出了,s=x+y-2^w=x+(y-2^w), 由上我们已知y<2^w,所以y-2^w<0
// 所以 s=x+(y-2^w) < x
// 推导出结论: s>x,没有溢出; s
//
// 取模运算: 10 mod 2=0(10对2取模,等于10除于2的余数)
// 05 商
// 2 10 十位的1捆(10根/捆)辣条不够分成两捆
// 10 把十位的1捆拆散成10根放到个位
// 10 10根可以分成两份,5根一份(商)
// 0 余 余数为0
// 1 mod 10(1对10取模)
// 0 商
// 10 1
// 1 余
// +u/w w位无符号数加法(和模2^w,可以被视为一种形式的模运算)
//w(word) s(sum) u(unsigned)/w(word) x,y=[0,2^w -1]
// w=3 s=x+y=[0,2^w+1 -2] s=x +u/w y=x+y mod 2^w(x+y对2^w取模)
// 1(110) ------- (x+y除于2^w的余数)
// 1(101) |
// 1(100) |
// 1(011) map3
// 1(010) |
// 1(001) |
// 1(000)-map1--|
// 111--map2--|--map2-> 111 111
// 110 |--map3-> 110 110
// 101 | 101 101
// 100 | 100 100
// 011 map1 011 011
// 010 | 010 010
// 001 | 001 001
// 000--map0--|-map0&1->000 000
// x+y --映射(这里map short for mapper,map:地图)--> x +u/w y
// s(sum)列中末端进位的数值就是溢出的s
//加法逆元(或称 相反数): 例如, 7的加法逆元是-7
//*unsigned encode无符号整数编码的本质: 一个数的十进制转换成二进制,这个二进制的位表示就是这个数的无符号整数编码
// 十进制数2和3,用2位二进制编码(无符号整数编码)表示,分别是[10],[11]
// 2+3的和等于5,用二进制编码表示是[101],这里机器位数2位,丢弃最高位,我们得到位表示[01],映射十进制值1
// 结果与 binary:101 mod 100 = 01 decimal:5 mod 4 = 1 模除结果一致
// B2U本质就是一个数的二进制转十进制: B2U[111] = 1*2^2 + 1*2^1 + 1*2^0 B2U[100] = 1*2^2 + 0*2^1 + 0*2^0
// B2U[111-100] = 1*2^2 + 1*2^1 + 1*2^0 - (1*2^2 + 0*2^1 + 0*2^0)
// B2U[11] = 1*2^1 + 1*2^0
// |--> bianry: 11
// [辣条,辣条,辣条]的数量--位置计数法--| (两个数字表示的辣条数量都是一致的)
// |--> decimal: 3
//
// 二补数加法(two's complement addition)---------------------------------------------------start
// 预备数学知识: start
// 下面三个指数幂统称整数指数幂
// 正整数指数幂的定义: w个2相乘的积记作2^w,称为2的w次幂
// 负整数指数幂的定义: 负指数幂等于把幂指数变号后所得的幂的倒数 2^-w = 1/2^w
// 零指数幂(底数为非零整数,因为除数不能为0,0作除数毫无意义):
// 2^w/2^w=1 2^w *1/2^w=1 2^w*2^-w =1 2^(w-w)=1 2*2*2/2*2*2=1(除于一次2相当于分母的幂指数减一次1,w-1)
// 2^0=1
//
// 2*2^(w-1)=2^1 * 2^(w-1)
// =2^1+w-1 = 2^w
// 2^w/2^1=2^(w-1) 就是w个2相乘,除于2,不就还剩w-1个2相乘
// =2^w * 1/2^1 1/2^1符合2^-1的定义
// =2^w * 2^-1 =第一行的结果
// *个人见解:为什么把2^-w定义为1/2^w幂指数变号得到的幂的倒数
// 2^3=2*2*2
// 2^3 *2=2^3 *2^1=2*2*2*2=2^4
// 2^3/2^1=2^3 *1/2^1=2*2*2/2=2^2=2^(3-1) -->所以定义 1/2^1=2^-1 (*2^1增加两倍,*2^-1刚好缩小两倍)
// 这样正整数指数幂和负整数指数幂作用刚好相反
// 英文定义感觉更容易理解:
// The power (or exponent) of a number says how many times to use the number in a multiplication(乘法).
// A negative exponent means how many times to divide by the number
//
// 2^w 乘法: 2^a * 2^b-->2^(a+b)
// 除法: 2^a/2^b-->2^(a-b)
// 举例: 2^3 * 2^2 = 2*2*2 * 2*2 = 2^5 = 2^(3+2)
// 2^3 / 2^2 = 2*2*2 / 2*2 =2 8分成4份,1/4四分之一份等于2
// = 2^1 = 2^(3-2)
// 2*2*2 / 2*2 = 2*2*2 * 1/(2*2)
// *数学乘除法的精髓,升华人生的知识点,理解完感觉自己飞升进入新境界了--' ...:
// 除法的本质,分成相同的份数(有存在余数的情况)
// 除法竖式的本质:(没有什么是一根辣条不能解决的,如果不能,那就一捆...)
// 63.5
// 2 127.0 桌子2:1捆辣条(100根/捆) 桌子1:2捆辣条(10根/捆) 桌子0:7根辣条
// 12 1.桌子2:1捆辣条(100根),没法分成两捆了(100根/捆),拆散分成10小捆(10根/捆)放到桌子1,
// 7 2.桌子1:现在有12捆(10根/捆),分成2份,每份6捆
// 6 3.桌子0:7根辣条,分成两份,每份3根,余1根,1根用刀分成10份,放到桌子-1
// 10 4.桌子-1:10份(1份/0.1根),再平均分成两份,变成5份
// 10
// 0
// 乘法的本质,将相同的数加起来的快捷方式,运算结果成为积,从哲学角度讲,乘法是加法由量变到质变的结果
//
//*武林绝学知识点之一,二补数转无符号数 和 无符号数转二补数的本质:
// --> w-1
// B2U(w)[ x 位向量]= ∑ x(i) * 2^i
// i=0
// --> w-2
// B2T(w)[ x 位向量]= x(w-1)*-2^(w-1) + ∑ x(i) * 2^i
// i=0
// -->
// binary(x) two's complement(x) unsigned(x)
// [011] 3 3
// [010] 2 2
// [001] 1 1
// [000] 0 0
// [111] -1 7
// [110] -2 6
// [101] -3 5
// [100] -4 4
// 通过观察上表的规律,B2U和B2T两个函数(function),T2U 和 u2T 的推导:
// 这里的_w是指下标w,表示字长
// |----> = x (x>=0) 这里的x是指二补数的x
// T2U_w(x) -|
// |----> = x + 2^w (x<0)
// 1. x>=0的情况比较直观,直接看B2U和B2T两个函数就可以直接看出,
// 输入相同编码(位向量),在xi=x(w-1)=0时(也就是无符号数编码和二补数编码最高位为0时),
// 函数输出的结果是一样的,所以映射到的真值相等
// 2. x<0的情况,
// 输入相同编码,在xi=x(w-1)=1时,
// B2U B2T 输出结果 只有x(w-1)位的位权是不同的,余下的数位 数值和位权都一致,所以结果也是一致的
// 无符号编码: x(w-1)位位权 2^(w-1)
// 二补数编码: x(w-1)位位权 -2^(w-1)
// 所以T2U(x),只要 -2^(w-1) + 2^w +剩下的位*位权之和 (无符号和二补数的和都一样)
// = -2^(w-1) + 2*2^(w-1) +剩下的位*位权之和
// = -2^(w-1) + 2^(w-1) + 2^(w-1) +剩下的位*位权之和
// = 2^(w-1) +剩下的位*位权之和
// --> -->
// U2T原理跟上面的T2U是一样的,这里就不详细展开了(要详细了解可以看《深入理解计算机系统第三版》P51):
// 1. x(unsigned)<=x(T's_c_max),B2U(w)[x]和B2T(w)[x]映射到的真值x是相等的
// 2. x(unsigned)>x(T's_c_max),理解的关键点:2^(w-1) - 2^(w-1) -2^(w-1)
// =2^(w-1) - 2*2^(w-1)
// =2^(w-1) - 2^w
//
//二补数加法(two's-complement addition)
// w位二进制位置计数系统,有2^w种组合方式,平分成两组,2^w/2=2^w * 2^-1=2^(w-1),
// 一半代表非负数(非负数还要有一个组合代表0),一半代表负数,得到如下取值范围,
// 取值范围: -2^w-1 <= x,y <= 2^w-1 -1
// 它们的和: -2^w-1 + -2^w-1 <= x+y <= 2^w-1 -1 + 2^w-1 -1
//
// 对取模运算(这里暂时主要讨论整数的取模运算)做个小小的了结:
// 注: modulo(模数) division(分裂,除法) modulo division(模除法) division operation(除法运算)
// multiplication(乘法)
// modulo operation(模除,取模操作,取模运算):模除得到的是一个数除以另一个数的余数.
// 给定两个正整数:被除数a和除数n, a modulo n(缩写为a mod n)得到的是使用欧几里德除法(带余除法)时a/n的余数
// 通常情况下a和n都是整数(对实数,浮点数取模也是可以的,这里暂时不讨论),余数r的取值范围[0,n-1],
// a mod 1恒等于0(a/1,除法本质:/1分成1份,肯定等于这个数本身啊,也肯定不存在余数啊,所以恒=0),a mod 0未定义
//
// (110)
// (101)
// (100)
// 011
// 010
// 001
// 000
// 111
// 110
// 101
// 100
// 1(011)
// 1(010)
// 1(001)
// 1(000)
//
//======================================================================================================
//20200103 真值与编码之间的数学原理的个人的一点理解:
//20200105 囧 越写越长了。。。以最新写的为准,越往下越新...
//二补数编码(two's complement encode)
//
// 二补数编码 十进制真值 二进制真值
// w=3 011 --map--> 3 = 011
// 100 --map--> -4 = -100
//
// binary(真值) decimal(真值)
// -100 + -100 = -4 + -4 真值的运算
// = -1000
//
// (1000-100)+(1000-100) = 100 + 100 (二补数+二补数) -->把减法转换成二补数的加法来运算求结果
// = -100 + -100 + 1000 + 1000
// = -1000 + 1000 + 1000 (-1000为 -100 + -100 的正确运算结果)
// = -1000 + 10000
// = 1000 (1000为减法运算正确结果的绝对值的二补数)
// = 000 + 1000
// 1000(减法转换为二补数加法运算后得到的结果)
// --> 1000的二补数是1000 1000 + 1000 = 1 0000(二补数之和)
// --> 再加上负号= -1000,得到减法运算的正确结果
//这是补数运算的数学原理
//
//上面的例子在计算机中的运算
// 直接看上例中这一步: = 000 + 1000 = 1000
// 因为计算机的计算数位位数是有限的,这里假设字长w=3,计算机只保留结果最后3位,相当于截断了结果1000
// 计算机中得到的运算结果是000,相当于1000 mod 1000 = 000(000和0是一样的)
// 所以计算机运算得到的这个例子的结果并不是 真值运算结果的绝对值的二补数,
// 因此最后用B2T函数映射到了一个错误的真值(即所谓的溢出)
// 1000二补数编码被截断了最高位,最高位为负位权,相当于要减去一个数得到运算结果,
// 现在舍去了这一位,运算结果再加上这个数就得到舍去最高位后的映射结果
//
//理解的关键点: 计算机运算的截断相当于数学中的模除(modulo)
// -001的二补数编码就是该数的绝对值的二补数,即001的二补数111
// 减法转二补数加法运算,从运算过程可以看出,结果由三部分组成:
//
// 1) 被减数为非负数(减数为非负数,减去一个负数等于加上这个数,就没讨论意义了):
// 真值运算结果 + 减数的绝对值和其绝对值的二补数之和
//
// 1.1) 如果真值运算结果大于等于0,则直接得到结果(二补数编码中,正整数的编码其实就是其二进制数),
// 因为被计算机运算舍去最高位(截断结果)相当于模除了减数的绝对值和其绝对值的二补数之和
// (计算机中参与运算的两个数数值位数肯定是相同的,位数不足的也会填充到位数相等,
// 二补数之和肯定是会末端进位的)
// 1.2) 如果真值运算结果小于0,则得到结果是这个负数真值运算结果的绝对值的二补数
// 因此得到的结果是负数真值结果的二补数,通过函数B2T可以直接映射到正确的真值结果
// (二补数编码,负整数的编码本质就是其绝对值的二补数,二进制数)
// 例如: w=3 真值结果= -001
// 则计算机运算结果= 111, 111就是-001的二补数编码
// B2T(111)=(这里省略计算的公式) -001 = -1
//
// 2) 被减数为负数:
// 真值运算结果 + 被减数的绝对值和其绝对值的二补数之和 + 减数的绝对值和其绝对值的二补数之和
// (因为计算机中参与运算的数的数值位数相同,
// 因此 被减数的绝对值和其绝对值的二补数之和 = 减数的绝对值和其绝对值的二补数之和)
// 得到 负数真值结果的二补数 + 被减数或减数的绝对值和其绝对值的二补数之和
// 被减数或减数的绝对值和其绝对值的二补数之和(计算机截断结果相当于模除掉这部分)
// = 负数真值结果的绝对值的二补数(也是负数真值结果的二补数编码)
// 在计算机中这个二补数编码 --映射--> 负数真值结果
// w=3 -001 + -001 = -010, |-010|=010
// 二补数运算: 111 + 111 = 1110
// = 1000-001 + 1000-001
// = 1 0000 - 010
// 001的二补数 + 001的二补数 = 010的二补数,所以二补数运算的结果等于负数真值运算结果的绝对值的二补数
//20200105主要看下面这一段就行了:
// 二补数运算举例:
// 1) 计算机:
// -100 + -100 + -100
// 101 + 100 (先计算前面两个)
// = 1000 - 100 + 1000 - 100
// = -1000 + 10000 (-100 + -100 = -1000)
// = 1000 (-1000的4位二补数,也是-1000在计算机中的二补数编码,这里假设字长w=3)
// w=3,这里截断数位,结果=000
// 000 + 100
// = 000 + 1000 + -100
// = 000 + 100
// = 100 B2T--map--> -4
// 所以计算机中: -4 + -4 + -4 = -4-4-4 运行结果= -4
//
// 如果字长w不受限制,是可以计算出正确结果的:
// -100 + -100 + -100
// 100 + 100 (先计算前面两个)
// = 1000 - 100 + 1000 - 100
// = -1000 + 10000 (-100 + -100 = -1000)
// = 1000 (-1000的4位二补数,也是-1000在计算机中的二补数编码,这里假设字长w=3)
//
// -1000 + -0100 = -1100
// = 1000 + 1100
// = 10000 - 1000 + 10000 - 0100
// = -1100 + 100000
// = -01100 + 100000
// = 10100 B2T--map--> (-12)10 (-01100)2=(-1100)2
// (10100为-1100的5位二补数,也是-1100在计算机中的二补数编码,计算机中w至少5位才能存储真值-1100)
// (负数在计算机中都是以二补数编码储存的)
//
// decimal | binary | unsigned encode | two's complement encode
// 7 111 111 0111
// -7 -111 - 1001
// -8 -1000 - 1000
//二补数编码比二进制数字长(数位)多一位才能储存这个二进制数
//注:1000属于特殊情况,1000的4位(w=4)二补数位就是1000
// 1111的二补数编码01111
//-1111的二补数编码,编码过程:
// -01111 --> |-01111| --> 01111 --> 10000(一补数) --> 10001(二补数)
//
//无符号编码: 7 --> 111 --> 111
// -7 --> -111 --> -
//
//通过十补数运算来理解-->计算机中的二补数运算
//(原理一样,但二进制数运算有其特殊性,计算机中算法也有其特殊性):
// 9 - 4 = 09 - 04 (等价于09 + -04) = 05
// --> 减法转十补数加法运算(计算机运用的十补数加法运算,数学中并不需要这样算)
// --> 09 + 96
// = 09 + 100 - 04
// = 09 - 04 + 100
// = 05 + 100
// = 105
// --> 105减去溢出部分100(与105mod100结果一样)
// --> 得到正确结果05
//
// 4 - 9 = 04 - 09(等价于04 + -09) = -05
// --> 04 + 91
// = 04 + 100 - 09
// = 04 - 09 + 100
// = -05 + 100
// = 95 (95为05的二位十补数)
// --> 求95的二位十补数,得到05
// --> 再加上负号,得到正确结果 -05
//
// -3-1 = -03-01(等价于-03 + -01)
// --> 97 + 99
// = 100 - 03 + 100 - 01
// = -04 + 100 + 100
// = 96 + 100
// = 196
// --> w=2,舍去最高位,截断结果(196 mod 100等效)
// --> 再求96的二位二补数,加负号,得到正确结果
//
// -4-4 = -04-04(等价于-04 + -04) = -08
// --> 96 + 96
// = 100 - 04 + 100 -04
// = -08 + 100 + 100
// = 92 + 100
// = 192 (舍去最高位,截断结果,再求2位十补数加负号,得到结果-08)
//
//*发生溢出是因为字长有限,字长不受限制的话减法转十补数/二补数的加法是永远可以得到正确结果的
// 真值结果非负数,补数运算结果就模除得到正确结果,真值结果为负数,补数运算结果就求相同数位补数再加负号即可得到正确结果
//======================================================================================================
void limits_head_constants(void); //函数声明,function declaration
void unsigned_int_operation(void);
void integer_multiplication(void);//multiplication乘法
void a_modulo_n(void);
void integer_constants_limits(void);
int main(void)
{
short int x,s,a = 6,b = -7;
unsigned short int i;
char c;
s = a + b;
printf("s=a+b = %hd\n", s);
printf("s=a+b = %hx\n", s);
printf("s=a+b = %hx\n", a + b);
printf("size of i:%d\n", sizeof(i));
printf("s=a+b = %hu\n", a + b);
//整数常量255 4byte 0000 0000 0000 0000 0000 0000 1111 1111
//赋值给char 1111 1111(只保留最后1byte)是负数-1的补码
//转换说明 short int 1111 1111 1111 1111 负数填充1111 1111
printf("%hd %hx\t %hx %hx\n", c = 255, c = 255, x = -255, -255);
//0111 1111 整数填充 0000 0000 0111 1111 前面填充0000 0000
printf("%hd\v %hx\n", c = 127, c = 127);
printf("%hd\n", x = 32768);
printf("\x41 \077\n"); //转移序列 \xhh十六进制
printf("what is you name\" \n");
printf("%hx\n", 1-2);
printf("4294967295 hexadecimal: %x,decimal: %u\n", 4294967295, 4294967295);
//decimal(4294967296): 1 0000 0000 0000 0000 0000 0000 0000 0000
//int constant 4byte: 0000 0000 0000 0000 0000 0000 0000 0000
// --> printf --> 0
printf("4294967296 hexadecimal: %x,decimal: %u\n", 4294967296, 4294967296);
//decimal(-4294967296): - 1 0000 0000 0000 0000 0000 0000 0000 0000
//two's complement: 1 0000 0000 0000 0000 0000 0000 0000 0000
//int constant 4byte: 0000 0000 0000 0000 0000 0000 0000 0000
// --> printf --> 0
//*注:-1000类型的负数的二补数编码属于特殊情况,其它都是二补数编码比真值数码多一位储存
printf("-4294967296 decimal: %u\n", -4294967296);
//decimal(-4294967295): - 1111 1111 1111 1111 1111 1111 1111 1111
// --> 二补数编码储存: - 1111 1111 1111 1111 1111 1111 1111 1111
// --> 需要33bit: - 0 1111 1111 1111 1111 1111 1111 1111 1111
//two's complement: 1 0000 0000 0000 0000 0000 0000 0000 0001
//整数常量4byte: 0000 0000 0000 0000 0000 0000 0000 0001
// --> printf --> 1
printf("-4294967295 decimal: %d, unsigned: %u\n", -4294967295, -4294967295);
limits_head_constants();
unsigned_int_operation();
integer_multiplication();
a_modulo_n();
integer_constants_limits();
return 0;
}
void limits_head_constants(void)
{
printf("int Max:%d\n", INT_MAX);
printf("int Min:%d\n", INT_MIN);
printf("unsigned int Max:%u\n", UINT_MAX);
printf("long Max:%ld\n", LONG_MAX);
printf("long Min:%ld\n", LONG_MIN);
/*
mingw compiler
printf("long long Max:%lld\n", LONG_LONG_MAX);
printf("long long Min(hexadecimal):%llx\n", LONG_LONG_MIN);
printf("unsigned long long Max:%llu\n", ULONG_LONG_MAX);
*/
//cygwin gcc
printf("long long Max:%lld\n", LLONG_MAX);
printf("long long Min(hexadecimal):%lld\n", LLONG_MIN);
printf("long long Min(hexadecimal):%llx\n", LLONG_MIN);
return;
}
void unsigned_int_operation(void)
{
short unsigned int us1 = 10, us2 = 20, result;
//无符号数一般不这样用,这里只是验证一下无符号数的编码储存
result = us1 - us2;
//本质是位向量的运算(bit vector),加上模和补数的知识,转换说明相当于"function",最后得到(映射到真值)结果,
//映射到啥就是啥了~
//数学术语双射,《深入理解计算机系统》(原书第三版)P44 无符号数编码,补码编码的唯一性
//个人心得:w(字长:计算机分配的数据存储长度)一样的情况下,binary都一样,只是映射到不同的真值,
// 映射到unsigned,反射回binary,这个binary就是unsigned encodings；
// 映射到two's complement number，反射回binary,这个binary就是补码编码
//注:个人心得未必正确,只是目前个人的理解.
//B2U[w](x:bit vector) {二进制数binary to 无符号数编码unsigned encodings} =映射--> 无符号整数(真值)
//U2B[w](x:decimal value) {二补数(补码)two's complement to 二进制数binary } =反射--> 二进制数(补码表示)
//B2T[w](x:bit vector) {二进制数binary to 二补数(补码)two's complement} =映射--> 有符号整数(真值)
//T2B[w](x:decimal value) {二补数(补码)two's complement to 二进制数binary } =反射--> 二进制数(补码表示)
printf("Wrong result:%hu,Right result:%hd,Right result:%hu\n", result, result, us1 + us2);
return;
}
void integer_multiplication(void)
{
short int a=2, b=6, c=16384, r;
// short int 16384 binary: 0100000000000000
// * 0000000000000010
// 0000000000000000
// 0100000000000000
// 01000000000000000
// w=16 1000000000000000 (结果为0100000000000000像左移一位)
printf("2*6=%hi,overflow:2*16384=%hi\n", r=a*b, r=c*a);
return;
}
void a_modulo_n(void)
{
short unsigned int a=11, n=2;
// %操作符为整数取模,fmod()函数包含在math.h里,浮点数取模
// (short int)1 对整型常量进行强制类型转换
printf("a mod n = %hu, a mod 1 =%hu\n",a%n, a%(short int)1);
printf("sizeof((short unsigned int)1): %d\n", sizeof((short unsigned int)1));
printf("sizeof(a*(short unsigned int)1):%d\n", sizeof(a*(short unsigned int)1));
printf("sizeof(a*n): %d\n", sizeof(a*n));
return;
}
void integer_constants_limits(void)
{
long long int lli1 = 9223372036854775807; /*lli2 = -9223372036854775808*/
//备忘:test2.c是在Linux系统下写的。。。
//c标准规定long int型大于等于int,存储字长看编译系统(4byte\8byte)
//整数常量作为有符号整数编码,即用二补数编码储存
//储存长度是可变的,4byte和8byte两种字长(gcc编译系统的原因)
//clang编译系统使用64为绝对地址储存整数常量
//C语言标准,C编译器也还是在不断发展的,目前clang和gcc为主流
//写C还是用linux比较好,编译系统比较新
//4byte[-2^31,2^31-1], 8byte[-2^63,2^63-1]
printf("sizeof(long long int):%d\n",sizeof(lli1));
printf("sizeof(2147483647):%d\n", sizeof(2147483647));
printf("sizeof(2147483648):%d\n", sizeof(2147483648));
printf("sizeof(4294967296):%d\n", sizeof(4294967296));
printf("sizeof(9223372036854775807):%d\n", sizeof(9223372036854775807));
//溢出:printf("sizeof(9223372036854775808):%d\n", sizeof(9223372036854775808));
//printf--> -1 现在用的编译系统的问题,long int和int都是32bit,%ld跟%d一样...
printf("9223372036854775807 d:%d\n", 9223372036854775807);
printf("9223372036854775807 ld:%ld\n", 9223372036854775807);
printf("9223372036854775807 lld:%lld\n", 9223372036854775807);
//printf("sizeof(9223372036854775808) lld:%lld\n", 9223372036854775808);
//编译时报错,整数常量字长最长为64bit,
//0111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111
//最大有符号整数
printf("-9223372036854775807 lld:%lld\n", -9223372036854775807);
printf("-9223372036854775807 llx:%llx\n", -9223372036854775807);
/*
long long int 最小值的定义
# define LLONG_MIN (-LLONG_MAX - 1LL)
*/
// long long int 最小值的正确输出方式:
printf("-9223372036854775808 lld:%lld\n", -9223372036854775807-1);
printf("-9223372036854775808 llx:%llx\n", -9223372036854775807-1);
printf("9223372036854775808u llu:%llu\n", 9223372036854775808u);
return;
}
#include #include
// ANSI(american national standards institute):美国国家标准学会
// 'x' 一个字符 | x | |
// "x" 一个字符串 | x | \0 |
// \0 空字符:null character(非打印字符)
//scanf()函数会自动添加空字符
//scnaf() 只会读取fyfa fyfb中的fyfa
//--------------------------------------------------------------
//conversion specification(转换说明) 例如: %d %f
// 1) printf() --> conversion specification表 《c primer plus第六版》P195
//--------------------------------------------------------------
//字符串常量 编译器会添加空字符
#include
#include#include
#include :
// * 0: 55 push rbp
// * 1: 48 89 e5 mov rbp,rsp
// * 4: 48 83 ec 30 sub rsp,0x30
// * 8: e8 00 00 00 00 call d :
// * 0: 55 push rbp
// * 1: 48 89 e5 mov rbp,rsp
// * 4: 48 83 ec 30 sub rsp,0x30
// * 8: e8 00 00 00 00 call d
#include
//带参数的函数 P293
#include P295 */
//
//原型(prototype),即函数的声明(function declaration),描述函数的返回值和参数(形参parameter)
// 1.该函数没有返回值(void空)
// 2.声明int类型的参数
void while_loop_function(int n); /* 函数原型声明function prototype declaration */
//int while_loop_function(int n); 函数返回值类型为int
//全局变量(global variable)
int gv_a = 0;
//主函数,程序入口
void main(void)
{
//局部变量(local variable)
char c;
int a;
float f;
//自动类型转换
c = 'A';
a = 5.5F;
f = 10;
while_loop_function(c);
while_loop_function(a);
while_loop_function(f);
while_loop_function(10);
return;
}
// 函数头圆括号中包含了一个int类型变量n的声明
// 该函数接受一个int类型的参数
void while_loop_function(int n)
{
while (n-- > 0){
printf("-");
}
printf("\n");
return;
}
// formal argument / formal parameter 形参(形式参数)
// actual argument / actual parameter 实参(实际参数)
// C99标准中:
// actual argument / actual parameter term术语 argument实参
// formal argument / formal parameter term术语 parameter形参
// 1.形参是函数头圆括号中声明的变量,
// 例如: 上面程序的变量n
// 2.实参是函数调用时提供(传递)的值,然后赋给形参
// 例如: 上面程序的 变量c,a,f;
// 常量10;
// 表达式也可以,比如 c+1
//
// void while_loop_function(int n) 函数头
// 圆括号中的变量声明创建了称为形参的变量n
//
// while_loop_function(10); 函数调用(function call)
// 把实参10传递给函数
//
// while_loop_function(a);
// 把a的值5赋给n
//
// * 变量名(局部变量local variable)是函数私有的,所以相同变量名在不同函数中是不冲突的
// const 恒定的,不变的
//
// 强制类型转换 --> 显式转换
// 自动类型转换 --> 隐式转换
// 结合律(求值顺序从左到右或从右到左)
// while语句是一种迭代语句
//
#include #include P328 表6.1 关系运算符
// absolute value 绝对值
scanf("%lf", &double_input);
// fabs函数,返回值为浮点数的绝对值
// double_input和PI的差的绝对值小于等于0.0001,while循环才会结束
while (fabs(double_input - PI) > 0.0001){
printf("No! input again: ");
scanf("%lf", &double_input);
}
return 0;
}
//表达式一定有一个值,关系表达式也不例外
//表达式为真的值是1,表达式为假的值是0
// while (q){
// printf("q\n");
// }
// 测试表达式q的值为真1
//关系表达式为真,求值为1;关系表达式为假,求值为0
//*在C中,所有非零值都为真(1),只有0被视为假,表达式一定有一个值,函数大部分也要返回值(这句话是核心,重点)
int true_value(void)
{
int a;
//while(a == 1)
// printf("true_value() run!");
return 0;
}
// == 关系相等运算符: 检查左值右值是否相等(比较)
// = 赋值运算符: 把右值赋给可修改的左值
// 关系运算符用于构建关系表达式
// 5 == n , n == 5是一样的
//
// 总结:
// 关系表达式真时值为1,关系表达式值为假时值为0
// 在C中,所有非零值为真,0为假,表达式都有一个值,函数大部分都有返回值
// *重要知识点:
// C标准库:
// 函数原型声明放在头文件 xxx.h (编译系统预处理阶段,读取并插入头文件文本)
// 函数定义放在其它源文件 xxx.c (已经提前编译好,编译系统链接阶段就是链接这些文件)
#include P388 对函数声明和使用带返回值的函数有比较详细的解释(很值得看的知识点)
//1.编译器遇到调用函数语句时,还没有遭遇到函数定义,不知道函数的返回值类型
// 通过前置声明(forward declaration)可让编译器知道函数的返回值类型,函数定义在别处
// (函数定义如果在main函数前,函数原型声明可以省略,但这不是C的标准风格)
// 附:通常函数定义(function definition)放在在其它文件中
//2.printf(),scanf()这些函数的原型声明(function prototype declaration)包含在stdio.h头文件里,
// #include 预处理指令,读取并插入头文件里的文本
// 这段main()程序是一个驱动(driver)示例,这段程序用来测试其它函数(function)
int main(void)
{
_Bool a = 1, b = 'a', c = 0, d = 88
, e = "abcd";
int input_limit_e;
double power_return_value, input_n;
printf("a = 1: %3d\n", a);
printf("b = 'a': %d\n", b);
printf("c = 0: %3d\n", c);
printf("d = 88: %2d\n", d);
printf("e = \"abcd\": %2d\n", d);
// 函数调用,读取函数返回值
// 函数的返回值存放在寄存器或内存(stack栈)
// 函数原型声明的返回值类型(必须,也是需要使用函数原型声明的原因):
// 编译系统编译到函数调用代码的时候,需要知道函数调用要读取的返回值的类型,知道数据类型才能知道要读取多长位宽的数据
// 但还没有编译到函数定义,所以需要通过函数原型声明知道返回值类型
// 函数原型声明的参数(非必须):
// 让函数调用可以传入正确的实参类型和个数
// 1.隐式函数声明,c99标准后已淘汰
// 2.函数类型声明 function type declaration
// int xxx();
// 缺点: 编译器检查不到函数调用时传入实参的类型和个数错误
// 3.函数定义声明,把函数定义放主函数前
// 缺点: 不利于代码的组织
// 4.函数原型声明 function prototype declaration
// int xxx(int xxx, float xxx);
// int xxx(void);
// 直接用函数原型声明就完事了...
// * C编译器很古老,有历史包袱...只会从头到尾编译一遍,所以有以上这些问题,比较新的语言就不会有这些声明的问题
bool_variable();
for_loop();
for_loop_nine_methods();
for_example();
comma_operator();
exit_condition_loop();
nested_loop();
nested_loop_other();
array();
for_array_average();
// scanf函数返回值为成功读取输入项个数,读取成功几个项返回值就为几,读取成功0个就为0
// EOF,end of file,文件终止符
// EOF在windows,linux,mac中有区别,具体上网查去,老子现在没心情也没空...
printf("input number and exponent:\n");
// 函数原型里n为double类型,输入整数类型也没关系,double类型等级比所有证书类型高,
// 整数类型会被自动转换(隐式转换)成double类型
// 函数原型power函数底数的变量用double类型是因为double类型能表示的范围更大更全面
//
// 输入 10 文本(ascii码),编译系统把它转换成 10.0 文本,再转换成double类型的binary储存
// (编译器具体怎么实现不清楚,但这个思路和结果应该是对的...
// 至少结果是对的,目前水平有限,这个思路让我能理解,未必精准或正确)
// 输入 a 文本或符号文本(这些转换成表示double类型的文本想想就过分啊...),所以当然输入错误咯...
while (scanf(" %lf %d", &input_n, &input_limit_e) == 2){
// 函数调用,把函数返回值返回给主函数
power_return_value = power(input_n, input_limit_e);
printf("number^exponent = %.2f\n", power_return_value);
}
printf("Game over! Bye~");
return 0;
}
int bool_variable(void)
{
// C99提供老stdbool.h头文件,该头文件定义了_Bool的别名bool,
// 把true和false定义为1和0的符号常量
// 包含了该头文件后,代码可以与C++兼容,true和false,bool为c++的关键字
bool a;
int b;
char c;
printf("input decimal number:\n");
// 1. 精简写法:
while (scanf("%d", &b)){
printf("true\n");
}
// 2. 非常啰嗦写法...
// 不用小括号, ==运算符优先级也比=高
//a = (scanf("%d", &b) == 1);
//while (a){
// printf("true\n");
// a = scanf("%d", &b) == 1;
//}
// 3. 很啰嗦写法...
//a = scanf("%d", &b) == 1;
//while (a){
// printf("true\n");
// a = scanf("%d", &b) == 1;
//}
// 4. 啰嗦写法...
//a = scanf("%d", &b);
//while (a){
// printf("true\n");
// a = scanf("%d", &b);
//}
//越啰嗦,可读性越高,但写起来确实啰嗦啊...
scanf("%c", &c);
printf("false! %d\n", c);
return 0;
}
// 知识点总结:
// precedence of relational operators(关系运算符优先级)
// 关系运算符优先级比算术(arithmetic)运算符低,比赋值运算符高
// 优先级高的先结合
// 关系运算符之间的优先级:
// 高优先级组: < <= > >=
// 低优先级组: == !=
// 与其他大多数运算符一样,关系运算符的结合律也是从左到右
// P340 表6.2 运算符优先级
// while语句是一种入口条件循环
// while (test expression/test condition)
// statement
// statement可以是简单语句,也可以是复合语句(花括号括起来)
// expression部分为假或0前,重复执行statement部分
// P343
// 1.不确定循环(indefinite loop) while测试表达式为假0之前,不确定要循环多少次
//
// 2.计数循环(counting loop) 循环之前就知道要循环多少次
// (1) 计数器初始化
// (2) 测试条件(与有限值比较)
// (3) 计数器递增(更新)
// 计数循环我们用for循环,虽然while循环(计数循环)也能实现
//for循环可以把上述3个行为(初始化,测试,递增[更新])组合在一起
int for_loop(void)
{
// a. 计数器初始化
// b. 循环一次(测试表达式为真);测试条件为假,终止循环,跳过计数器更新,执行后面的代码
// c. 计数器更新(递增)
int a;
// a = 1; 初始化只执行一次(once),循环开始前
// for循环圆括号中的表达式也叫控制表达式,它们都是完整表达式
// a++循环结束时求值
for (a = 1; a <= 5; a++){
printf("for loop: %d\n", a);
}
// 由此可看出,a <= 5表达式为假0,循环结束,后面的a++表达式不执行
printf("out of for loop, a: %d\n", a);
return 0;
}
int for_loop_nine_methods(void)
{
int n, m = 2;
//int n, m;
char c;
double f;
// for循环 控制表达式 n--,n=n-2,n=n-10也可以,根据需求
for (n = 5; n >= 0; n--){
printf("decrement counter n-- : %d\n", n);
}
// for循环 控制表达式 n++,n=n+2,n=n+10也可以,根据需求
for (n = 5; n <= 10; n = n + 2){
printf("increment counter n = n + 2 : %d\n", n);
}
// 可以用字符代替数字计数,(该程序能正常运行,是因为字符在计算机内部跟数字一样以二进制数存储)
for (c = 'a'; c <= 'z'; c++){
printf("character: %c, ASCII(decimal): %d\n", c, c);
}
// 上面三条测试条件都是测试 迭代(iteration)次数(控制循环次数)
// 还可以测试其他条件,例如 n * n < 100,测试限制n的平方的大小
// 递增的量可以算术增长,也可以几何增长
for (f = 1.0; f <= 10.0; f = f * 1.2){
printf("f * 1.2 : %.13f %a\n", f, f);
}
// 第三个表达式可以使用任何合法的表达式,无论是什么表达式,每次迭代都会更新该表达式的值
// int y = 10;
// for (x = 1; y <= 50; y = ++x * 2 + 5)
// 这里可以这么理解,计数器x的代数计算的值赋值给y,对y作测试
// 可以正常运行,但编程风格不好
for (n = 1; n <= 5;){
// 计数器更新部分也可以放进循环体内
n = n + 2;
}
printf("%d\n", n);
// for循环的控制表达式,三个表达式可以使用不同的变量
for (n = 1, f = 1.0; f <= 5.0; f = 2 * n * f){
printf("OK_1!\n");
}
//clang编译器,m没有初始化,测试表达式的值为假0
//for (; m <= 5;){
//for循环控制表达式三个表达式可以省略,但两个分号不能省略
//测试条件为空语句,值为真,程序无限循环
//for (;;){
//语法上虽然可以省略三个表达式,但这样代码貌似没有任何实际意义啊...
for (m = 1; m <= 5;){
m++;
printf("%d\n", m);
}
printf("%d\n", m);
return 0;
}
// *** for循环控制表达式总结(核心知识点,遵循一下三点原则):
// 1. 计数器初始化
// 1.1 第一个表达式也可以是其他表达式(即使函数表达式也可以)
// 1.2 只在循环开始前执行一次(once)
// 2. 测试条件(测试表达式)
// 2.1 如果测试条件为空语句,则值一直为真,程序无限循环
// 3. 计数器更新(递增:算术递增,几何递增都可以;可以把这个表达式放入循环体内)
// 3.1 放在控制表达式,循环结束一次,执行一次
// 3.2 放在循环体内,循环一次,执行一次
// 注: 可以省略三个表达式,但两个分号不能省略(其它随便你折腾...)
// 1表达式 可以放在for语句前进行初始化
// 2表达式 空语句值一直为真
// 3表达式 可以放循环体内
// 个人总结(while和for的区别):
// while (测试条件test condition)
// for (控制表达式,三个表达式)
// while和for都是入口条件循环(entry condition loop)
//
// while: 1.不确定循环; (程序运行完成前无法确定循环迭代次数)
// 2.计数循环; (程序运行前就可知循环迭代次数,计数循环一般用for)
// for循环只需记住几个重点就好:
// 三个控制表达式,三个表达式都可以省略,两个分号不能省略
// 计数器初始化可以在for语句前,只在for循环前执行一次
// 计数器更新可以在循环体内,迭代一次,执行一次;在控制表达式,循环迭代结束一次,执行一行
// 测试条件为空语句,值为真
// 形式:
// for (initialize; test; update)
// statement
//
// initialize 初始化 (计数器初始化)
// initialize表达式在for循环迭代之前值执行一次
// test 测试 (测试条件)
// update 更新 (计数器更新)
int for_example(void)
{
int x;
//三个控制表达式
for (x = 1; x < 1; x++){
printf("OK");
}
printf("%d\n", x);
return 0;
}
// 其他赋值运算符
// 可修改的左值,右值(常量,变量,可求值的表达式)
// y += 2 y = y + 2
// y -= 2 y = y - 2
// y *= 2 y = y * 2
// y /= 2 y = y / 2
// y %= 2 y = y % 2
// y += x y = y + x
// y *= x + 2 y = y * (x + 2)
// 1.组合形式的赋值运算符让代码更紧凑
// 2.与一般形式相比,这些组合形式的赋值运算符生成的机器代码更高效
// 逗号运算符(comma): ,
// 逗号运算符并不局限于for循环使用
// 逗号运算符的两个性质:
// 1.保证了被它分隔的表达式从左到右求值
// (换言之,逗号是一个序列点sequence point,左侧项的所有副作用side effect在执行右侧项之前发生)
// n++, n * 2; 左侧子表达式,右侧子表达式
// 2.整个逗号表达式的值是右侧项的值
int comma_operator(void)
{
int a, x, y, z;
//逗号comma表达式的值是右侧(项/表达式)的值
a = (5,6);
printf("%d\n", a);
//先执行赋值表达式,右侧子表达式什么也没做(实际在计算机内部有没有做还要看汇编代码)
a = 5,6;
printf("%d\n", a);
//逗号运算符,保证被分隔的表达式从左至右求值
//逗号运算符,整个逗号表达式的值是右侧项的值 (逗号运算符运算求值)
//圆括号,先对逗号表达式(comma expression)求值
x = (y = 3, (z = ++y + 2) + 5);
// ------------------------ --> 逗号表达式
printf("x = (y = 3, (z = ++y + 2) + 5); ");
printf("x: %d\n", x);
//逗号运算符,整个逗号表达式,两个子表达式(subexpression)
//整个逗号表达式的值等于逗号右边的子表达式的值
x = y = 3, (z = ++y + 2) + 5;
// ---------------------------- --> 逗号表达式
printf("x = y = 3, (z = ++y + 2) + 5; ");
printf("x: %d\n", x);
return 0;
//逗号运算符(comma operator),当作一个序列点(sequence point)
//逗号运算符的运算符优先级是C所有运算符里最低的(google查的...)
}
// *逗号也可用作分隔符,不是逗号运算符,例如在变量声明和函数参数列表中的逗号就是分隔符
// P259 表5.1
// 组合赋值运算符 与 赋值运算符 优先级 相同
// x *= y + 5 与 x = x * (y + 2) 相同
// 运算符优先级
// 运算符 结合律
// () 从左到右
// + - (一元) 从右到左
// * / 从左到右
// + - (二元) 从左到右
// = 从右到左
//
// *逗号运算符把两个表达式连接成一个表达式(逗号表达式),并保证左边的子表达式先求值
// 整个逗号表达式的值是逗号运算符右侧子表达式的值
// 入口条件循环 entry condition loop
// while for
// 循环每次迭代前检查(执行)测试条件
// 出口条件循环 exit condition loop
// 出口条件循环 do while
// 循环的每次迭代之后检查(执行)测试条件
// do
// {
// statement
// } while ( expression );
int exit_condition_loop(void)
{
int a = 1;
do
{
printf("exit condition loop: %d\n", a);
a++;
} while (a <= 5);
printf("exit loop: %d\n", a);
return 0;
}
//入口条件循环用for或while都可以:
// 让for像while一样
// for ( ;test; ) 与 while (test) 效果相同
//
// 让while像for一样
// 计数器初始化;
// while (测试条件) {
// 循环体;
// 计数器更新;
// }
// 与 for (计数器初始化;测试条件;计数器更新) 循环效果相同
// 具体看 P372,觉得有点啰嗦,懒得做笔记...
// 我个人总结的话: while适合不确定循环,for适合计数循环
// do while 适合先执行一次循环的迭代,再执行测试条件
// nested loop 嵌套循环
// 指在一个循环内包含另一个循环
int nested_loop(void)
{
int m;
char c;
// outer loop 外层循环
for (m = 0; m <= 5; m++){
// loop body
printf("row %d: ", m);
// inner loop 内层循环
for(c = 'a'; c <= 'z'; c++){
// nested loop body
printf("%c", c);
}
printf("\n");
}
return 0;
}
// 嵌套循环(nested loop)中,外层循环(outer loop)每迭代一次,内层循环(inner loop)迭代到测试条件为假0为止
int nested_loop_other(void)
{
int m;
char c;
// 三个控制表达式
for (m = 0; m <= 5; m++){
//函数的核心,外层循环每迭代一次,内层循环计数器初始化的值递增
//当然,还可以把递增扩展到内层循环测试条件(测试表达式),这里就不展开了
for (c = 'A' + m; c <= 'F'; c++ ){
printf("%c", c);
}
printf("\n");
}
return 0;
}
// array数组,是按顺序存储的一系列类型相同的值
// 整个数组有一个数组名,下标(subscript)必须是整数,下标从0开始计数,数组的元素依次存储在内存中相邻的位置
// 通过整数下标(subscript)访问单独的项(item)或元素(element)
// 编译器不会检测数组下标的错误
// int a[10]; 声明可储存10个int类型值的数组
// a[0] = 10; 数组下标(subscript)从0开始
// a[15] = 10; 数据还是会被存放,有可能会导致程序异常中断
// 数组的类型可以是任意数据类型
int array(void)
{
// 声明int类型数组
int a[9];
// 声明char类型数组
char c[9];
a[0] = 15;
printf("%d\n", a[0]);
return 0;
}
int for_array_average(void)
{
int subscript, score[5];
double sum = 0;
printf("input 5 scores:\n");
for (subscript = 0; subscript < 5; subscript++){
scanf("%d", &score[subscript]);
//隐式转换 int --> double 类型级别低的转换为类型级别高的
sum += score[subscript];
}
printf("scores: ");
for (subscript = 0; subscript < 5; subscript++){
printf("%d ", score[subscript]);
}
printf("\n");
printf("average: %.2f\n", sum/5.0);
return 0;
}
// 键入enter键后程序开始读取输入缓冲区的数据
// 函数返回值的循环示例
// 幂power
// n^e n为底数,e为指数
double power(double n, int limit_e)
{
int e;
//从算法理解,先把power的结果(幂的值)初始化为1.0
double pow = 1.0;
//幂的指数e在for循环三个控制表达式的第一个表达式计数器初始化中初始化
for (e = 1; e <= limit_e; e++){
// 指数为1,幂的值为底数n本身
// 指数为2,幂的值为n * n,再赋给左侧的项
// 指数为3,幂的值为n * n * n,再赋给左侧的项
// ......
pow *= n;
// 左侧的项乘以右侧的项,再把乘积付给左侧的项
}
//返回值类型已在函数头声明,为double类型
//可以返回 常量,变量,表达式
//返回值为 常量的值,变量的值,表达式的值
return pow;
}
#include P421 表7.1 ctype.h头文件中处理字符的函数
// 字符测试函数 测试特定类型字符,是特定类型字符,返回值为真,反之为假0
// 字符映射函数 返回值为修改后的值,但不修改原值
#include P424
// if else嵌套形式也可以实现,效果一样,但还是上面的else if清晰明了
// if else嵌套形式有兴趣可以了解
//
// if (expression)
// statement;
// else
// if (expression)
// statement;
// else
// statement;
// 嵌套的if else语句被视为一条语句,因此可以不用花括号括起来,但括起来让代码更加清晰
// 好了,说了这么多if else嵌套语句,总结,else if语句真香...
printf("game over!\n");
return 0;
}
// C99标准要求编译器至少支持127层嵌套
// nested if 嵌套if
// if与else的匹配(先if后else,else if不在这里的讨论范围)
// else与离它最近的if语句(包括有括号和无括号的if语句)匹配
// 反正就是与最近的if语句相匹配呗...
// *找else相匹配的if要向前找
// *编译器是忽略缩进的,因此不能通过缩进来判断if与else的匹配
//
// if (expression)
// statement;
// if (expression) -- if
// statement; | 匹配
// else -- else
// statement;
//
// if (expression){ -- if
// statement; |
// if (expression) | 匹配
// statement; |
// } |
// else -- else
// statement;
//
// 100^2 = 100 * 100 100^1 = 100
// 100^2 * 100^1 = 100 * 100 * 100 = 100^(2+1) = 100^3
// 100^0.5等于100的平方根
// 100^0.5 * 100^0.5 = 100^(0.5+0.5) = 100^1
int division(void)
{
int div, num;
for (div = 2, scanf("%d", &num); div < num; div++){
// num % div
// num模除div,余数为0的就是能整除的
if (num % div == 0){
printf("num / div = %d, div = %d\n", num / div, div);
}
}
// optimize 优化
return 0;
}
// 数学知识点:
// 自然数: 0和正整数
// 素数(质数prime number): 大于1的自然数,且除了1和自身,不能被其它自然数整除
int prime_number(void)
{
long unsigned int div, num;
// bool为_Bool的别名,在stdbool.h头文件中定义
bool is_prime_number;
while (scanf("%lu", &num) == 1)
{
// for 计数循环(counting loop)
// 根据素数的定义,除了1和数本身,依次循环2至少数的前一位数
// for循环开始前div,is_prime_number初始化,且仅初始化一次
for (div = 2, is_prime_number = true; div < num; div++)
{
// 如果数能被其它自然数整除,这个数就不是素数,标记flag设置为假false
if (num % div == 0){
printf("Not prime number, %lu is divisible by %lu.\n"
, num, div);
is_prime_number = false;
}
}
// is_prime_number为真,说明数不能被除1和本身之外的自然数整除,是素数(质数)
if (is_prime_number == true){
printf("Yes, %lu is prime number!\n", num);
}
}
return 0;
}
// 2也是素数(比较特殊的素数),但在程序中,for测试条件为假,is_prime_number为真,
// 没经过if测试语句验证,经过if测试语句的话is_prime_number就为假了,所以for测试条件为假算是歪打正着吧...
// 这段程序还是有个缺陷,会把0,1(可通过while测试条件验证)当成素数,学到后面的逻辑运算符再完善
// 逻辑运算符
// && 与
// || 或
// ! 非
// if else
//
// if (expression)
// statement
//
// if (expression)
// statement1
// else
// statement2
//
// if (expression1)
// statement1
// else if (expression2)
// statement2
// else
// statement3
//
// statement可以是一条简单语句或复合语句
#include P440
// iso646.h
// && 与 and
// || 或 or
// ! 非 not
// iso646.h头文件定义了一批常用运算符的可选拼写(定义了宏)
// 因为不同地区的键盘是有不同的,有的键盘不一定有美式键盘的一些符号
// 但我是直接用美式键盘的,因此对这个无感...
// 目的:解决有的键盘没有这些符号的问题
// alternative n 可供选择的; adj 可供替代的
// spellings 拼写
// 感觉翻译成 可供替代的拼写 更好理解
// 简而言之:非美式键盘与可能没有某些符号键,导致不能输入某些运算符,
// 因此C的iso646.h头文件定义了一组宏,提供了可替代的拼写,代替无法输入的运算符
// 宏的定义有点像符号常量
// P440
// 逻辑运算符优先级
// !优先级之比圆括号运算符低,与递增运算符相同,(应该+/-正负运算符也是一样的)
// &&和||的优先级比关系运算符低,比赋值运算符高
// &&优先级比||高
// 运算符优先级operator precedence暂时小结(不全):
// ()圆括号
// >> !逻辑运算符非,+/-正负符号,++/--自增自减运算符
// >> + - * / % 加减乘除 模除
// >> == != > >= < <= 关系运算符
// >> &&逻辑运算符与and >> ||逻辑运算符或or
// >> =赋值运算符和+=等组合赋值运算符
// >> ,逗号运算符comma
// P440
// *我觉得是很重要的一个知识点:求值顺序
// 两个运算符共享一个运算对象,运算顺序取决与运算符优先级(例如:5+3-2 5+3*2)
// 除了两个运算符共享一个运算对象的情况外,C通常不规定复杂表达式的哪个部分先求值
// a = (5 + 3) * (2 - 1)
// C把先求值5+3,还是先求值2-1的决定权交给编译器的设计者
// 但c保证&&和||的求值顺序从左往右(还有一个是逗号运算符)
// &&或||是一个序列点,左侧项副作用发生完才会执行下一步运算
// C语言的陷阱...
// C只有两个运算符共享一个运算对象,&& || , ?:运算符的求值顺序是确定的
// 因此要多点用(),不然在不同的编译器、操作系统、特定机器下,运算结果可能会有不同
// 多用()才是一个好习惯...
// 短路计算:
// && operand1为0假,短路计算,整个逻辑表达式为假
// || operand1为1真,短路计算,整个逻辑表达式为真
// *重要概念
// 优先级: 决定运算对象与相邻两个不同运算符(我感觉更精确的说法是优先级不同的运算符)的结合顺序
// 结合律: 决定运算对象与相邻两个相同优先级运算符的结合顺序
// 3 + 2 * 5 *优先级比+高,2先与5结合
// 3 + 2 - 5 +和-优先级相等,按结合律从左往右结合,先+后-
// 简而言之:两个运算符共享一个运算对象,与运算符优先级高的结合;运算符优先级相等的,根据结合律(从左往右或从右往左)
// a = 2 && 1 < 2 (&&右侧的操作数为1 < 2的值,所以可以把1 < 2看作&&右侧的操作数)
//解析: 根据优先级,操作数2与&&结合,对左侧操作数求值为2
// c规定&&求值顺序从左往右,&&作为序列点,左侧操作数副作用发生完,再对右侧操作数求值
// 根据优先级,操作数1与<结合,1 < 2子表达式为&&的右操作数,求值结果为1
// &&表达式结果为1,再把1赋值给a
//
// && || 逻辑运算符,序列点,保证左侧操作数求值完(副作用发生完),再对右侧操作数求值
// , 逗号运算符,序列点,同上
// ; 序列点,左侧语句副作用发生完,再执行右侧语句
int lower_character(void)
{
char ch;
int n;
printf("\na: %d ,z: %d.\n", 'a', 'z');
printf("lower character:\n");
for (ch = 'a'; ch <= 'z'; ch++){
// char,shor int运算时被升级(promotion)成int类型
// for (ch = 97; ch <= 122; ch++){
printf("%c ", ch);
}
printf("\n");
for (n = 90; n <= 130; n++){
if (n >= 'a' && n <= 'z'){
printf("Lower character, %d, %c\n",
n, n);
}
else {
printf("Not lower character: %d.\n",
n);
}
}
return 0;
}
// P443
// EBCDIC不像ASCII码那样连续编码和相邻字符一一对应
// 因此不能像ASCII码处理
// 要判断EBCDIC是否为小写字符,用islower()函数来处理
// islower()函数原型声明在ctype.h头文件
#include //git config --global credential.helper store (github免密码,要先账号密码登陆一次)
#include