第五章 TC 算术运算符和算术表达式
5.1 概述
TC语言中运算符和表达式数量之多,在脚本语言中是少见的,正是丰富的运算符和表达式使TC 语言功能十分完善。这也是TC语言的主要特点之一。
TC语言的运算符具有不同的优先级,在表达式中,各运算量参与运算的先后顺序要遵守运算符优先级别的规定.
5.2 TC运算符简介
TC语言的运算符可分为以下几类：
1.算术运算符:用于各类数值运算。包括加(+)、减(-)、乘(*)、除(/)、求余(或称模运算，%)。
2.关系运算符:用于比较运算。包括大于(>)、小于(=)、小于等于(
3.逻辑运算符:用于逻辑运算。包括与(&&)、或(||)、非(!)三种。 4.赋值运算符:用于赋值运算，分为简单赋值(=).
算术运算符用来计算,关系和逻辑运算符,用来作比较,赋值运算符,用来给变量赋值.
5.3算术运算符和算术表达式 1.基本的算术运算符
加法运算符“+”：加法运算符为双目运算符，即应有两个量参与加法运算。如a+b,4+8等。 减法运算符“-”：减法运算符为双目运算符。但“-”也可作负值运算符，此时为单目运算，如-x,-5等 乘法运算符“*”：双目运算.
除法运算符“/”：双目运算。参与运算量均为整型时，结果也为整型，舍去小数。
如果运算量中有一个是浮点型，则结果为浮点型。
〖例〗
1.字符型 字符
2.字符=字符串.格式化(\"\\n\\n%d,%d\\n\",20/7,-20/7) 3.辅助.消息框(字符) 4.字符=字符串.格式化 (\"\\n\\n%d,%d\\n\",20.0/7,-20.0/7) 5.辅助.消息框(字符) 复制代码
本例中，20/7，-20/7的结果均为整型，小数全部舍去。而20.0/7和-20.0/7由于有字符型参与运算，因此结果也为实型。
求余运算符(模运算符)“%”:双目运算。要求参与运算的量均为整型。 求余运算的结果等于两数相除后的余数。 【例】
1.字符型 字符
1 2.字符= 字符串.格式化(\"%d\\n\",100%3) 3.辅助.消息框(字符) 复制代码
本例输出100除以3所得的余数.
2.算术表达式和运算符的优先级
表达式是由常量、变量、功能和运算符组合起来的式子。一个表达式有一个值及其类型， 它们等于计算表达式所得结果的值和类型。表达式求值按运算符的优先级进行。单个的常量、变量、功能可以看作是表达式的特例。 算术表达式是由算术运算符和括号连接起来的式子。
算术表达式：用算术运算符和括号将运算对象（也称操作数）连接起来的、符合TC语法规则的式子。
以下是算术表达式的例子：
1.a+b 2.(a*2)／c 3.(x+r)*8-(a+b)／7 复制代码
运算符的优先级:TC 语言中,运算符的运算优先级共分为8级.1级最高,9级最低.在表达式中,优先级较高的先于优先级较低的进行运算,同优先级下,在TC中,都是从左向右计算.
一级,[](数组下标调用),功能调用, 二级,!(逻辑非运算)
三级,()(括号里面的表达式)
四级,*(乘操作),/(除操作),%(求余) 五级,+(加法),-(减法)
六级,>( 大于),=(大于等于),
第六章 TC的关系运算符和表达式
6.1 概述
在程序中经常需要比较两个量的大小关系，以决定程序下一步的工作,这样的比较运算在TC中称为关系表达式,运算符号称为关系运算符.
6.2 关系运算符
比较两个量的运算符称为关系运算符。
关系运算符及其优先次序
在TC语言中有以下关系运算符： 1.
2. 大于
2 4.>= 大于或等于 5.== 等于 6. != 不等于
关系运算符都是双目运算符，其结合性均为左结合。关系运算符的优先级低于算术运算符，高于赋值运算符。在六个关系运算符中，,>=的优先级相同，高于==和!=，==和!=的优先级相同。
6.2 关系表达式
关系表达式的一般形式为：表达式,关系运算符 ,表达式
例如：
1.a+b>c-d 2.x>3/2 3.
复制代码
都是合法的关系表达式,关系表达式的值一定是为逻辑型,真 或者是 假,如：5>0的值为“真”。(a=3)>(b=5)由于3>5不成立，故其值为假。
6.3 逻辑运算符和表达式
逻辑运算符极其优先次序,TC语言中提供了三种逻辑运算符： 1.&& 与运算 2. || 或运算 3. ! 非运算
与运算符&&和或运算符||均为双目运算符.非运算符!为单目运算符,具有右结合性。逻辑运算符和其它运算符优先级的,关系可表示如下：
1.!（非）→&&(与)→||(或) 复制代码
“&&”和“||”低于关系运算符，“！”高于算术运算符。
按照运算符的优先顺序可以得出：
a>b && c>d 等价于 (a>b)&&(c>d)
!b==c||dc&&x+yc)&&((x+y)
逻辑运算的值
逻辑运算的值也为“真”和“假”两种。其求值规则如下：
1.与运算 &&：参与运算的两个量都为真时，结果才为真，否则为假。
例如：
5>0 && 4>2 由于5>0为真，4>2也为真，相与的结果也为真。
2.或运算||：参与运算的两个量只要有一个为真，结果就为真。 两个量都为假时，结果为假。
3 例如：
5>0||5>8
由于5>0为真，相或的结果也就为真。
3.非运算!：参与运算量为真时，结果为假；参与运算量为假时，结果为真。
例如： !(5>0) 的结果为假。
虽然TC编译在给出逻辑运算值时，逻辑运算值只有“真”，“假”这2个值。不是\"真\"就为\"假\"。
逻辑表达式
逻辑表达式的一般形式为：表达式 逻辑运算符。
其中的表达式可以又是逻辑表达式，从而组成了嵌套的情形。
例如：(a&&b)&&c
根据逻辑运算符的左结合性，上式也可写为： a&&b&&c
逻辑表达式的值是式中各种逻辑运算的最后值，以“真”和“假”分别代表。
下面做个表达式的综合实例: [例]
1.功能 逻辑型 测试(逻辑型 a,整型 b,整型 c) 2.如果(a&&(c>b)) 3. 辅助.消息框(\"a等于真并且c大于b\") 4.如果结束 5.
6.如果(!a||(c+b)>100) 7. 辅助.消息框(\"a等于假或者c加b的值大于100\") 8.如果结束 9.10.返回 真
11.功能结束
复制代码
以上代码中,我们不难看出,如果测试函数传入的参数a为真,并且c大于b的时候,会弹出对话框\"a等于真并且c大于b\" ,如果传入的参数a为假,并且b+c的值大于100的时候,会弹出对话框\"a等于假或者c加b的值大于100\" .
第七章 TC 过程化程序设计
7.1 概述
过程化程序设计是一种以事件为中心的编程思想,就是分析出解决问题所需要的步骤，然后用功能把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了。
面向过程其实是最为实际的一种思考方式,就是算面向对象的方法也是含有面向过程的思想.可以说面向过程是一种基础的方法.它考虑的是实际的实现.一般的面向过程是从上往下步步求精.所以面向过程最重要的是模块化的思想方法.对比较面向对象,面向对象的方法主要是把事物给对象化,对象包括属性与行为.当程序规模不是很大时,面向过程的方法还会体现出一种优势,因为程序的流程很清楚,按着模块与功能的方法可以很好的组织.比如拿学生早上起来的事情来说说这种面向过程吧.粗略的可以将过程拟为:
(1)起床
(2)穿衣
(3)洗脸刷牙
(4)去学校
而这4步就是一步一步的完成,它的顺序很重要,你只须一个一个的实现就行了,我们用TC的形式表现出来
1.空间 我的一天 2.
3.功能 逻辑型 起床() 4.//起床...5.返回 真 6.功能结束 7.
8.功能 逻辑型 穿衣() 9.//穿衣...10.11.12.13.14.15.16.17.18.19.20.21.22.返回 真 功能结束
功能 逻辑型 洗脸刷牙() //洗脸刷牙...返回 真 功能结束
功能 逻辑型 去学校() //去学校...返回 真 功能结束
5 23.空间结束
复制代码
我们调用的时候就这样了
1.我的一天.起床() 2.我的一天.穿衣() 3.我的一天.洗脸刷牙() 4.我的一天.去学校() 复制代码
过程化程序设计中,我们经常把把一个问题分解成若干小问题,再对每个小问题进行分解(分模块),知道每个问题的难度都足以小,能够解决为止,然后再把这些小问题合并,就解决了大问题,一般要完成过程化程序设计主要由以下三种逻辑结构组成:
顺序结构：顺序结构是一种线性、有序的结构，它依次执行各功能 循环结构：循环结构是重复执行一个或几个模块，直到满足某一条件为止 选择结构：选择结构是根据条件成立与否选择程序执行的通路
采用过程化程序设计方法，程序结构清晰，易于阅读、测试、排错和修改。由于每个模块用功能定义封装,执行单一功能，模块间联系较少，使程序编制比过去更简单，程序更可靠，而且增加了可维护性，每个模块可以独立编制、测试. 下面我们来一一介绍它们.
第八章 TC 如果语句
8.1 如果语句
如果语句,也就是 如果 语句,用如果语句可以构成分支结构.它根据给定的条件进行判断,以决定执行某个分支程序段.TC语言的如果语句有两种基本形式,并且每个如果语句的结尾都要有一个如果结束。
(注:关键字中英文对应关系,如果else,如果结束select,条件default,选择结束while,循环结束endfor)
图解：
实例：
1.
2.功能 逻辑型 测试() 3.整型 i=0 4.遍历(100) 5. i=i+1 6.遍历结束 7.返回 真
8.功能结束
复制代码
本例程序将重复执行100次循环，每执行一次，i值加1。
2、条件表达式的遍历
遍历(整型 i=0;i
注： 整型 i ： 表示定义了一个遍历语句的变量。
i
i++ ： 这个语句相当于 i = i + 1 。
图解：
实例：
1.
2.功能 逻辑型 测试() 3.整型 sun=0 4.遍历(整型 i=0;i
7.辅助.消息框(转换.整型转字符型(sun))
15 8.返回 真 9.功能结束
10.
复制代码
10.1.3 跳出语句
跳出语句通常用在循环语句中。如果没有跳出语句,则将成为一个死循环而无法退出。当跳出语句用于循环语句中时,可使程序终止循环而执行循环后面的语句, 通常跳出 语句总是与如果语句联在一起。即满足条件时便跳出循环。
(注:关键字中英文对应关系,跳出continue) 循环 (表达式1)
……
如果 (表达式2)继续
……
如果结束
循环结束 例:
1.
2.功能 逻辑型 测试() 3.整型 i=0 4.循环(i
如果(i
如果结束 9. i=i+1 10.11.循环结束 返回 真
12.功能结束
复制代码
事例中当i的值小于50的时候,i每次都是加2的,当i的值大于50的时候就每次加1了。
第十一章 TC 功能定义
11.1 TC功能概述:
功能是TC源程序的基本模块,通过对功能模块的调用实现特定的功能.TC语言中的功能相当于其它高级语言的子程序,在其他高级语言中,比如C,C++中,称为函数.允许用户建立自己定义的功能。用户可把自己的算法编成一个个相对du立的功能模块，然后用调用的方法来使用功能。可以说TC程序的全部工作都是由各式各样的功能完成的，所以也把TC语言称为功能式语言。
由于采用了功能模块式的结构，TC语言易于实现结构化程序设计。使程序的层次结构清晰，便于程序的编写、阅读、调试。
在TC语言中可从不同的角度对功能分类。
一.从功能定义的角度看，功能可分为TC库功能(API)和用户定义功能两种。 1) TC库功能(API)：由TC系统提供，用户无须定义，也不必在程序中作类型说明，只需在程序中直接调用即可。
17 2) 用户定义功能：由用户按需要写的功能。对于用户自定义功能，不仅要在程序中定义功能本身，而且在主调功能模块中还必须对该被调功能进行类型说明，然后才能使用。
二.TC语言的功能兼有其它语言中的功能和过程两种功能，所有TC功能都是有返回值的功能：此类功能被调用执行完后将向调用者返回一个执行结果，称为功能返回值。如数学功能即属于此类功能。由用户定义的这种要返回功能值的功能，必须在功能定义和功能说明中明确返回值的类型。
三.从主调功能和被调功能之间数据传送的角度看又可分为无参功能和有参功能两种。
1) 无参功能：功能定义、功能说明及功能调用中均不带参数。主调功能和被调功能之间不进行参数传送。
2) 有参功能：也称为带参功能。在功能定义及功能说明时都有参数，称为形式参数(简称为形参)。在功能调用时也必须给出参数，称为实际参数(简称为实参)。进行功能调用时，主调功能将把实参的值传送给形参，供被调功能使用。
四.TC语言提供了极为丰富的(API)库功能，这些库功能又可从功能角度分类。具体可以在TC程序中或者帮助文档中看到相应的功能功能和使用说明。 功能定义的一般形式
(注:关键字中英文对应关系,功能endfunction,返回 - return)
1.无参功能定义的一般形式
1.功能 功能类型 功能名() 2.//声明部分 .....语句 3.//执行的操作 4.返回 功能类型 5.功能结束
6.
复制代码
其中功能类型和功能名称为功能头。返回类型指明了本功能的类型，功能的类型实际上是功能返回值的类型.该返回类型与前面介绍的TC的各种类型相同。功能名是由用户定义的标识符，功能名后有一个空括号，其中无参数，但括号不可少。功能到功能结束中的内容称为功能体。功能体是执行具体操作的功能调用的集合,它完成了功能的实现操作.
1.功能 逻辑型 Hello() 2.//这里添加你要执行的代码 3.辅助.消息框(\"Hello,world \") 4.返回 真
18 5.功能结束
复制代码
这里，Hello作为功能名的功能，Hello功能是一个无参功能，当被其它功能调用时，弹出Hello world对话框。
2.有参功能定义的一般形式
1.功能 功能类型 功能名(形式参数表列) 2.//声明部分 .....语句 3.返回 功能类型
4.功能结束
复制代码
有参功能比无参功能多了一个内容，即形式参数表列。在形参表中给出的参数称为形式参数，它们可以是各种类型的变量，各参数之间用逗号间隔。在进行功能调用时，主调功能将赋予这些形式参数实际的值。形参既然是变量，必须在形参表中给出形参的类型说明。例如，定义一个功能，用于求两个数中的大数，可写为：
1.功能 整型 max( 整型 a, 整型 b) 2.如果 (a>b) 3.返回 a 4.否则 5.返回 b 6.如果结束
7.功能结束
复制代码
第一行说明max功能是一个整型功能，其返回的功能值是一个整数。形参为a,b,均为整型量。a,b的具体值是由主调功能在调用时传送过来的。在function 和endfunction 中的功能体内，除形参外没有使用其它变量，因此只有语句而没有声明部分。在max功能体中的return语句是把a(或b)的值作为功能的值返回给主调功能。有返回值功能中至少应有一个return语句。
11.2 功能的参数和功能的值 1.形式参数和实际参数
前面已经介绍过，功能的参数分为形参和实参两种。在本小节中，进一步介绍形参、实参的特点和两者的关系。形参出现在功能定义中，在整个功能体内都可以使用，离开该功能则不能使用。实参出现在主调功能中，进入被调功能后，实 19 参变量也不能使用。形参和实参的功能是作数据传送。发生功能调用时，主调功能把实参的值传送给被调功能的形参从而实现主调功能向被调功能的数据传送。 功能的形参和实参具有以下特点：
形参变量只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。因此，形参只有在功能内部有效。功能调用结束返回主调功能后则不能再使用该形参变量。
实参可以是常量、变量、表达式、功能等，无论实参是何种类型的量，在进行功能调用时，它们都必须具有确定的值，以便把这些值传送给形参。因此应预先用赋值，输入等办法使实参获得确定值。
实参和形参在数量上，类型上，顺序上应严格一致，否则会发生类型不匹配”的错误。
功能调用中发生的数据传送是单向的。即只能把实参的值传送给形参，而不能把形参的值反向地传送给实参。 因此在功能调用过程中，形参的值发生改变，而实参中的值不会变化
例:
1.空间 测试 2.功能 逻辑型 A() 3.整型 n=100 4.测试.B(n) 5.返回 真 6.功能结束 7.
8.功能 整型 B( 整型 n) 9.整型 i=n-1 10.11.12.13.14.15.
16.
复制代码
循环(i>=1) n=n+i i=i-1 循环结束 返回 n 功能结束 空间结束
20 在A功能中输入n值等于100，并作为实参，在调用时传送给s 功能的形参量n( 注意，本例的形参变量和实参变量的标识符都为n，但这是两个不同的量，各自的作用域不同)。n值为100。即实参n的值为100。把此值传给功能s时，形参n的初值也为100，在执行功能过程中，形参n的值变为5050。返回主功能之后，输出实参n的值仍为100。可见实参的值不随形参的变化而变化。
2.默认参数和引用传值参数 1).默认参数:
前面已经介绍过，功能的参数分为形参和实参两种。功能通过定义形参的数据类型,调用该功能者则需要传入一个和形参相同的数据类型的参数来调用。通常情况下,功能定义了多少个参数个数,调用该功能者必须传递相应数据类型的参数个数,如果用户在功能定义参数的时候予以了初始值,调用该功能者,可以根据需要如果不需要这个参数的时候,可以不用对该参数进行赋值调用.或者修改其默认值进行调用都可以,这种功能参数的定义方式就是默认参数定义。 例:
空间 我的程序
功能 整型 默认参数(整型 参数A,整型 参数B=0) .....//语句 返回 0 功能结束
功能 整型 A(整型 参数A)
我的程序.默认参数(参数A)//第二个默认参数可以选择不传值
我的程序.默认参数(参数A,10)//第二个默认参数可以传入其他整型值 返回 0 功能结束
空间结束
以上例子,我们可以看到,功能:默认参数中,有2个参数,第一个是整型参数,第二个也是整型参数,但在定义的时候赋初始值等于0了,也就是默认参数。所以功能A在调用功能默认参数的时候,除了第一参数必须传入一个整型参数外,第二个默认参数可以选择性的选择传入另外一个整型值或者不传任何值。
2).引用传值参数: 前面已经介绍过，功能的参数分为形参和实参两种。功能调用中发生的数据传送是单向的。即只能把实参的值传送给形参，而不能把形参的值反向地传送给实参。 因此在功能调用过程中，形参的值发生改变，而实参中的值不会变化。但通过我们的引用传值参数方式可以改变这种数据是单向的传递方式,我们在做一个功能定义参数的时候,在参数前面加一个\"&\"符号,就说明了这个参数属于引用传值。调用该功能者,在给该功能的引用传值传入参数变量的时候,如果调用者对该引用传值传入参数变量进行重新赋值的时候,在该功能调用结束的时候,该引用传值传入参数变量的值会等于调用者中重新赋予的新值，这种功能参数的定义,以 \"&\"符号 出现的时候,就属于引用传值参数 。
21 例:
空间 我的程序
功能 整型 引用传值(整型 &A, 整型 &B) A=A*2 B=B*4 返回 0 功能结束
功能 整型 普通传值(整型 A,整型 B) A=1, B=2
我的程序.引用传值(A,B) 返回 0 功能结束
以上例子中,功能:引用传值,定义了2个引用传值的参数A和B,功能:普通传值, 在调用功能引用传值的时候, 传入了变量A,和变量B, 变量A的值赋值等于1, 变量B的值赋值等于2, 而引用传值功能会将传入的变量A的值乘于2, 将变量B的值乘于4, 所以在功能:引用传值执行到返回的时候, 传入的变量A的值由原来的1等于1*2改变等于2, 而变量B的值由原来的2等于2*4改变等于8。
3.功能的返回值
功能的值是指功能被调用之后，执行功能体中的程序段所取得的并返回给主调功能的值。对功能的值(或称功能返回值)有以下一些说明：
1) 功能的值只能通过return语句返回主调功能。
返回语句的一般形式为：
返回 表达式
或者为：
返回 (表达式) 该语句的功能是计算表达式的值，并返回给主调功能。在功能中允许有多个返回语句，但每次调用只能有一个返回语句被执行，因此只能返回一个功能值。 2) 功能值的类型和功能定义中功能的类型应保持一致。 例:
1.
2.空间 测试
3.功能 整型 A(整型 a, 整型 b) 4.返回 a+b 5.功能结束 6.
7.功能 整型 B( 整型 a, 整型 b)
22 8.如果 (a>b) 9.返回 a 10.11.12.13.否则
返回 测试.A(a,b) 如果结束 功能结束
14.空间结束
复制代码
功能A中，
返回了2个参数中和的表达式,功能B者通过比较参数的大小来返回，
如果参数a大于参数b返回参数a，
否则传参数a和b给功能A做返回值进行返回。
第十二章 TC 功能的调用
12.1 TC 功能的调用
前面已经说过，在程序中是通过对功能的调用来执行功能体的，其过程与其它语言的子程序调用相似，通过功能所属的空间来引用调用功能的。TC语言中，功能调用的一般形式为：
空间名.功能名(实际参数表)
对无参功能调用时则无实际参数表。实际参数表中的参数可以是常数，变量或其它构造类型数据及表达式。各实参之间用逗号分隔。
(注:function对应TC中文为:功能，endfunction对应TC中文为:功能结束，return对应TC中文为:返回)
功能调用的方式在TC语言中，可以用以下几种方式调用功能：
1.功能表达式：功能作为表达式中的一项出现在表达式中，以功能返回值参与表达式的运算。这种方式要求功能是有返回值的。例如：z=max(x,y)是一个赋值表达式，把max的返回值赋予变量z。
2.功能实参：功能作为另一个功能调用的实际参数出现。 例:
1.空间 测试
2.功能 整型 A(整型 a) 3.返回 a+100 4.功能结束 5.功能
6.整型 B(整型 b) 7.返回 b+100 8.功能结束
23 9.功能 整型 C(整型 a,整型 b) 10.11.12.13.14.15.整型 max=测试.A(a)+测试.B(b) 返回 max 功能结束
功能 整型 D(整型 a,整型 b) 返回 测试.C(测试.A(a),测试.B(b)) 功能结束
16.空间结束
复制代码
功能C中整型 max=测试.A(a)+测试.B(b)，是一个赋值表达式，把功能A和功能B的返回值赋予变量max。功能D者是以功能A和功能B做为了功能C的实际参数,调用了功能C,做为了返回值。
被调用功能的功能原型
在TC语言中主调功能中调用某功能之前不需要做任何声明，只要改功能功能已经编写完成而且该功能所在的空间中进行引用即可。这与使用变量之前要先进行变量说明是一样的。在主调功能中对被调功能作说明的目的是使编译系统知道被调功能返回值的类型，以便在主调功能中按此种类型对返回值作相应的处理。 例:
1.空间 测试
2.功能 整型 A(整型 n) 3.返回 测试.B(n) 4.功能结束
5.功能 整型 B(整型 n) 6.返回 测试.A(n) 7.功能结束
8.空间结束
复制代码
在同一个空间中,功能间相互调用,只需要功能所在的空间的空间名:测试，引出功能名()就可以调用成功了。例子中的空间名为:测试，测试空间中有功能A和功能B，功能A要调用功能B,因为功能B要传一个整型变量,所以就这样测试.B(n)就可以调用到了，同理功能B调用功能A，也是测试.A(n)即可。
第十三章 TC 空间定义
13.1 空间定义概念
命名空间就相当于一个名称,命名空间里面包含的是功能定义和全局变量的定义,如果在不同名称的命名空间中有相同的功能名,则表示的是不同的含义,一般
24 我们可以这样理解,空间就是把一套功能分了类,比如TC自带的空间,把字符串的处理的功能都封装成了 字符串空间里面.,窗口的一套功能都是封到 窗口空间里面的.
我们来举例说明:
一般我们新建一个项目,TC会默认为我们创建一个 以项目名称 命名的空间,这个空间名是不能修改的,假如我建了一个名称为 我的程序 的项目,会默认生成下面的代码.
举例代码如下:
1.空间 我的程序 //定义默认空间
2.功能 逻辑型 开始_点击() //这里添加你要执行的代码 3.返回 真//函数返回语句 4.功能结束
5.功能 逻辑型 退出_点击() //这里添加你要执行的代码 6.辅助.退出() 7.返回 真 //函数返回语句 8.功能结束
9.空间结束 //空间结束语句
复制代码
TC的默认生成的空间,自动生成的一些功能或者属性框生成的功能,一般都是事件功能,TC都封在这个默认空间里,这里的 开始_点击和退出_点击,都是界面上面两个默认按钮,开始按钮和退出按钮的点击事件,所触发的功能,也就是说,生成的EXE,当点击开始按钮时,就会执行 开始_点击 功能,事件机制这里不多做介绍,其他会有专门的介绍.假如我们想自己定义一个空间,叫 我的数学,里面实现一个加法运算,我们需要这样写:例:
1.空间 我的程序 2.//定义默认空间
3.功能 逻辑型 开始_点击() 4.//这里添加你要执行的代码 5.整型 和
6.和=我的数学.加法(10,10) 7.返回 真 8.//函数返回语句 9.功能结束 10.功能 逻辑型 退出_点击() 25 11.12.13.14.15.16.17.18.19.20.21.22.23.24.25.26.27.28.//这里添加你要执行的代码 辅助.退出() 返回 真 //函数返回语句 功能结束 空间结束 //空间结束语句
//这里是自定义的空间 空间 我的数学
//这里是自定义的空间里面实现的一个自定义的功能.功能 整型 加法(整型 x,整型 y) //这里添加你要执行的代码 整型 和=x+y 返回 和 //函数返回语句 功能结束 空间结束
29.//空间结束语句
复制代码
这里,我们实现了一个 自定义的空间 叫 我的数学 ,并在这个空间里面实现了一个 加法功能,我们在 默认空间 我的程序里面 的 开始_点击()功能里调用了它,调用的格式为 我的数学.加法(10,10) 它返回了10+10的结果.这样就实现了,我们的自定义的空间,大家还可以陆续在里面添加其他的功能,比如减法,乘法,什么的,当然我们这里只是举一个例子,这些功能都是直接可以用操作符实现的.
数组
数组，顾名思义就是一组同类型的数。
一、数组的声明
声明数组的语法为：在数据类型后加方括号括来说明。本接仅介绍一维数组。下面是一个整型数组的例子：
1.整型[] array= 整型[10] 复制代码
这条语句定义了一个具有10个整型元素的名为array的数组。方括号中的维数表达式可以包含运算符，但其计算结果必须是一个长整型值。这个数组是一维的。 下面这些声明是合法的：
1.整型[] offset = 整型 [5*2]
26 2.浮点型[] count = 浮点型[5*2+3] 3.
复制代码
下面是不合法的：
1.整型[] offset= 整型 [5*2/3] // 数组的大小不能为浮点数
2.
复制代码
二、用下标访问数组元素
1.整型[] offset= 整型 [5*2] 复制代码
表明该数组是一维数组，里面有10个数，它们分别为offset[0],offset[1],……offset[9]；千万注意，数组的第一个元素下标从0开始。一些刚学编程的人员经常在这儿犯一些错误。 offset[3]=25; 上面的例子是把25赋值给整型数组offset的第四个元素。 在赋值的时候，可以使用变量作为数组下标。
1.整型 下标 = 0 2.整型[] offset =整型[5*2] 3.重复(10) 4. offset[下标] =辅助.随机数(10,30) 5. 下标 =下标 + 1 6.重复结束
7.
复制代码
题目的意思是随机产生10~30之内的10个整数，存入到数组中。
三、数组的初始化
前面说了，变量可以在定义的时候初始化，数组也可以。
1.整型[] array = 整型[5] 2.array[0] = 1 3.array[1] = 2 4.array[2] = 3 5.array[3] = 4 6.array[4] = 5
27 7.
复制代码
初始化值的个数可以和数组元素个数一样多。
如果初始化的个数多于元素个数，将产生编译错误；如果少于元素个数，其余的元素被初始化为0。
举个例子：
1.输入5个整数存入数组中，然后把它们从小到大排列并放在同一数组中。(思路：先找出最小的，放在第一个位置，为了防止把原先的数覆盖掉，可以把原先的第一个数和最小数的位置互换)。
1.整型[] array = 整型[5] 2.整型 i=0,j=0,min=0,stmp=0 3.
重复(5) 4. array[i] =辅助.随机数(10,30) // 随机生成5个数 5. i =i + 1 6.
重复结束 7.
字符型 输入内容
8. 输入内容 = 字符串.格式化(\"随机数为:%d,%d,%d,%d,%d\", array[0] , array[1] , array[2] , array[3] , array[4]) 9.
辅助.消息框(输入内容) 10.11.12.13.14.15.16. //// 开始排序 i=0 循环(iarray[j]) // 里面的4行语句很重要 17.18.19.20.21.22.
min=array[j] stmp=array[i] array[i]=array[j] array[j]=stmp 如果结束 j = j + 1
28 23.24.25.26. 循环结束 i = i + 1 循环结束
输入内容 = 字符串.格式化(\"排列后的数据为:%d,%d,%d,%d,%d\", array[0] , array[1] , array[2] , array[3] , array[4]) 27.辅助.消息框(输入内容) 复制代码
分析：先让第一个值作为基准，如果后面有比它小的，那么就把这两个数互换一下，同时把基准换成小的值。两个数互换应该这样(stmp=a;a=b;b=stmp;)，而不是(a=b;b=a;)，想想这是为什么？必须要用一个变量作为桥梁。这种一个一个的把最小的放在前面的排序方法，我们形象的叫做冒泡法。
二维数组
比方说我们熟知的坐标系，在2D游戏里，一组(X，Y)坐标决定人物的位置，而这里的坐标，我们就可以用二维坐标来描述。 二维数组的定义：数据类型 [][] 数组名
比方我们知道游戏里的5组坐标，那么我们就可以定义一个这样的二维数组： 整型[][] 坐标 = 整型[5][2]
这个就可以很清楚的表示：列号为0的表示X坐标，列号为1的表示Y坐标。
二维数组的引用
二维数组和一维数组的使用差不多，不过二维数组提供了二种方法遍历，一种是：先横向再纵向，另一种是：先纵向再横向。不过二种方法的效果都是一样的！那么我们来看看具体怎么访问二维数组。 例如：
1.整型[][] 坐标 = 整型[5][2]
29 2.整型 i=0,j=0 3.循环(i
循环(j
坐标[i][j]=辅助.随机数(11,32) 7. j = j + 1 8.
循环结束 9. i=i+1 10.循环结束
复制代码
二维数组的大小：整型[][]坐标 = 整型[5][2] // 大小为 5*
2三维数组 定义：
类型[][][] 数组名 如：整型[][][] 变量
初始化大小：变量 = 整型[10][2][3] 数组的大小/长度： N*N*N 整型[10][2][3]这里的大小为10*2*3=60
数组的访问：数组名 [下标1][下标2][下标3] 下标的值为0~N-1 N为数组的长度。
多维数组操作复杂，一般用到二维就够了。
TC操作的文件，一般有三种：INI格式文件，TXT格式文件，图片文件。
1、
图片文件
图片文件一般都是用做界面美化的资源，以及找图命令的资源。例如：
1.整型 图像序号,返回的x坐标,返回的y坐标 2.图像序号=图像.找图(0,0,1440,900,\"d:\\111.bmp|d:\\222.bmp|d:\\333.bmp\",#203040,0.8,0,返回的x坐标,返回的y坐标) 3.如果(图像序号>=0) 4.辅助.消息框(转换.整型转字符型(返回的x坐标)) 5.
辅助.消息框(转换.整型转字符型(返回的y坐标)) 6.
辅助.消息框(\"找到该图\") 30 7.否则
8. 辅助.消息框(\"没有找到该图\") 9.如果结束
复制代码
2、
INI文件
是windows的系统配置文件所采用的存储格式，统管windows的各项配置，一般用户就用windows提供的各项图形化管理界面就可实现相同的配置了，但在某些情况，还是要直接编辑.ini才方便。
格式： INI文件是由 节、键、值组成。
节： 就是文件里中括号所表示的内容。如：[数据域] 键与值：就是文件里等号两边的内容。例如：name=张三，那么这里的name就是键，而键的值，我们就称之为值。
在TC里操作INI的命令
1.辅助.写配置(\"RealmName\",\"East\",\"serverGerman\",\"D:\\abc.ini\") 复制代码
RealmName为节，East为键，serverGerman为值，D:\\abc.ini为INI文件路径。
1.字符型 字符串 2.字符串=辅助.读配置(\"RealmName\",\"East\",\"D:\\abc.ini\") 3.辅助.消息框(字符串) 复制代码
读配置其实就是获取INI文件里的值，一个INI文件里，这个值是通过节与键来确定的。
3、
TXT文件
TXT的文件操作比较复杂，所以TC提供了一个专门处理文件的空间，叫文件。这一套完整的命令，已经足够我们处理如何文件了！ 3.1、创建文件
整型 创建(字符型 path,字符型 attribute=\"创建文件\")
第一个参数是文件的路径，第二个是文件的属性，可以是一个也可以是多个的组合。返回值是成功创建文件的文件句柄，创建失败则返回0，所以在使用的时候，要判 断函数的返回值。 例如：
31 1.整型 文件句柄
2.文件句柄=文件.创建(\"d:\\1.txt\",\"读写|共享读|共享写|总是创建\") //自定义属性 3.如果(文件句柄==0) 4.辅助.消息框(\"文件创建失败\") 5.否则
6.
辅助.消息框(\"文件创建成功\") 7.
文件.关闭(文件句柄) 8.如果结束
复制代码
3.
2、打开文件
整型 打开(字符型 path,字符型 attribute=\"读写|共享读|共享写|文件要存在\")
第一个参数是文件的路径，第二个是文件的属性，可以是一个也可以是多个的组合，返回值是成功打开文件的文件句柄，打开失败则返回0，所以在使用的时候，要判断函数的返回值。
3.3、关闭文件
逻辑型 关闭(整型 handle)
这里的handle为文件句柄，这个参数是创建文件或者打开文件的返回值。当文件不需要操作了，或者是操作完毕了，我们都应该关闭文件，释放掉系统的资源。
3.4、设置文件的读写位置
逻辑型 设置游标位置(整型 handle,字符型 pos)
这个命令是用来控制文件的读写位置，可以从文件头位置开始，或者是文件结束位 置开始。当我们打开文件或者是创建文件时，文件的读写位置是在文件头位置。
例如：
1.整型 文件句柄
2.文件句柄=文件.打开(\"d:\\1.txt\") 3.文件.设置游标位置(文件句柄,\"开始\") 4.文件.设置游标位置(文件句柄,\"结束\") 5.文件.关闭(文件句柄) 复制代码
3.5、向文件写入内容
32
逻辑型 写入(整型 handle,字符型 inputstr)
在当前的文件读写位置，向文件中写入指定的内容。handle为文件句柄，这个参数是创建文件或者打开文件的返回值。
逻辑型 写一行(整型 handle,字符型 str)
在当前的文件读写位置，写入指定的内容，并且会自动换行，而写入命令是不会自动换行的。这个命令也可以直接使用写入命令来实现，只需要在写入的内容后面增加换行符（”\\r\\n”），”\\r”表示回车，”\\n”表示换行。代码如下：
1.文件.写一行(文件句柄,\"aaaa\") 2.// 等价于
3.文件.写入(文件句柄,\" aaaa \"+”\\r\\n”)
复制代码
这2个写内容方法使用时，需要注意一个问题：如果写入位置在文件头，那么当文件头有内容时，会覆盖原来的内容。如果写入的内容比原有的内容长，那么会完全覆盖原有内容；如果写入的内容比原有内容短，那么只会覆盖写入长度的内容，还有一部分原有内容会保留！
逻辑型 末尾写入(整型 handle,字符型 inputstr)
在文件的末尾位置写入内容，使用这个命令的时候，TC会自动将文件的写入位置设置到文件的末尾，之后再写入数据。所以这个命令也可以用写入命令来实现，只需要在写入内容之前，将文件的写入位置设置到文件的结束位置就可以了。代码如下：
1.文件.末尾写入(文件句柄,\" aaaa\") 2.// 等价于
3.文件.设置游标位置(文件句柄,\"结束\") 4.文件.写入(文件句柄,\" aaaa\") 复制代码
3.6、获取文件的长度
整型 长度(整型 handle)
命令的返回值表示获取到文件的总大小。
3.7、判断指定路径的文件是否存在
逻辑型 是否存在(字符型 path)
这个命令用来判断指定路径的文件是否存在，如果文件不存在，则返回假，存在则返回真。这个命令一般用了打开文件的操作之前。
更多的文件操作命令，我们可以参照TC的帮助文档，只要打开TC软件，点击软件的右上角的问号，就可以打开帮助文档，之后在TC API说明里找到文件命名空间。
TC网络空间通信
33 TC的网络通信根据TCP/IP和UDP协议实现的，因此遵守协议的规定。那么我们先来熟悉下这2个协议吧。
UDP协议
UDP协议是英文User Datagram Protocol的缩写，即用户数据报协议，主要用来支持那些需要在计算机之间传输数据的网络连接。UDP协议从问世至今已经被使用了很多年，虽然其最初的光彩已经被一些。
类似协议所掩盖，但是即使是在今天，UDP仍然不失为一项非常实用和可行的网络传输层协议。尤其是在需要很强的实时交互性的场合，如网络游戏、视频会议等，UDP协议更是显示出极强的威力。
UDP协议是一种面向非连接的协议，面向非连接指的是在正式通信前不必与对方先建立连接，不管对方状态就直接发送。至于对方是否可以接收到这些数据内容，UDP协议无法控制，因此说UDP协议是一种不可靠的协议。
UDP适用于一次只传送少量数据、对可靠性要求不高的应用环境。因为UDP协议是面向非连接的协议，没有建立连接的过程，因此它的通信效率高；但也正因为如此，它的可靠性不如TCP协议高。
UDP协议的主要作用是完成网络数据流量和数据报之间的转换：在信息的发送端，UDP协议将网络数据流量封装数据报，然后将数据报发送出去；在信息的接收端，UDP协议将数据报转换成实际数据内容。
实际上，我们可以认为基于UDP协议的Socket类似于一个码头，该码头的作用就是负责发送、接收集装箱，一个数据报类似于一个集装箱。因此对于基于UDP协议的通信双方而言，没有所谓的客户端和服务器端的概念。
TCP/IP协议
TCP/IP是发展至今最成功的通信协议之一,其开放性的特点成为了因特网的基础。
在TCP/IP网络应用中,通信的两个进程间相互作用的主要模式是客户机/服务器模式。
服务器是一个进程,它一直等待着客户进程的请求以便为客户进程服务， 客户进程向服务器提出请求,服务器对请求做出相应的处理并执行被请求的任务,然后将结果返回给客户机。这里还要讲到一个概念套接字(Socket),Socket是通信基石,是支持TCP/IP协议网络通信的基本单元。
一个Socket就是一个通信的端点,用以一个短整数来表示。
注意:Socket不是端口号,它只是一个句柄,代表网络协议中的一组数据,这组数据包括TCP连接中双方IP地址以及目前连接状况。 一个正在被 使用的Socket都有它的类型和与其相关的网络应用进程。
在介绍UDP协议基础内容方面，我们需要对UDP和TCP进行一下简单的对比： TCP协议：可靠，传输大小无限制，但是需要连接建立时间，差错控制开销大。 UDP协议：不可靠，差错控制开销较小，传输大小限制在64K以下，不需要建
34 立连接。
根据通信性质,Socket可以分为两类: Stream Socket(会话套接字):使用TCP协议,提供一种面向连接的可靠数据通信方式.当要发送在批量数据或想让发出的数据按顺序无重复地到达目的地时,就要使用会话套接字,但需要很多开销。
Datagram Socket(数据报套接字):使用UDP协议,提供不可靠的,非连接的数据通信方式,具有向多个目标地址发送广播数据报的能力,由于其并不十分可靠,需要应用程序负责管理数据报的排序和可靠性。
总之,若要用TCP协议那Socket就必须设为Stream,反之,用UDP就设为Datagram。
UDP协议的使用
下面介绍下UDP服务器、客户端的流程： UDP服务端创建流程
1、初始化网络环境(网络.初始化())
2、创建套接字(网络.套接字())
3、绑定套接字并开启端口(网络.绑定())
4、接收或发送数据(网络.接收来自()、网络.发送到())
5、关闭套接字(网络.关闭套接字())
6、关闭初始化网络环境(网络.关闭())
UDP客户端创建流程
1、初始化网络环境(网络.初始化())
2、创建套接字(网络.套接字())
3、接收或发送数据(网络.接收来自()、网络.发送到())
4、关闭套接字(网络.关闭套接字())
5、关闭初始化网络环境(网络.关闭())
图解如下：
35
UDP模式注意: UDP模式的服务端概念比较模糊,需要接收数据需要 绑定端口,这时可以看做是服务端了,如果只发送数据不需要 绑定端口,这时可以看做是客户端(客户端只能接收来自他发送过消息的服务器传回的消息,不能接收来自别的客户端的消息),UDP模式下先打开服务端或先打开客户端都可以,如果在接收方打开之前,发送数据,这之前发送的数据将会丢失,UDP模式只管发送数据,不管数据是否到达。
实例源码如下： 服务器代码
1.网络.初始化() //初始化网络环境
2. 整型 服务器套接字句柄=网络.套接字(2) //创建数据报(UDP)套接字
36 3.网络.绑定(服务器套接字句柄,9999) //开启了计算机的9999端口,供外界连接 4.
整型 rPort 5.
字符型 接收缓存,rIP,发送缓存=\"客户端，我是服务器端！\" 6.
循环(真) 7. 如果(网络.接收来自(服务器套接字句柄,接收缓存,100,rIP,rPort) )//接收数据 8.
辅助.消息框(接收缓存) 9.
网络.发送到(服务器套接字句柄,发送缓存,rIP,rPort) 10.11.12. 如果结束
循环结束
网络.关闭套接字(服务器套接字句柄) //关闭套接字释放资源
13.
复制代码
客户端代码 网络.关闭() //关闭网络环境释放资源
1.网络.初始化() //初始化网络环境
2.整型 服务器套接字句柄=网络.套接字(2) //创建数据报(UDP)套接字 3.整型 rPort 4.字符型 接收缓存,rIP,发送缓存=\"服务器，我是客户端\" 5.网络.发送到(服务器套接字句柄,编辑框.获得文本(\"编辑框0\"),\"127.0.0.1\",9999) //向指定地址端发送一串字符串 6.网络.接收来自(服务器套接字句柄,接收缓存,100,\"127.0.0.1\",9999) //接收数据
7.辅助.消息框(接收缓存) //打印从指定地址接收的字串 8.网络.关闭套接字(服务器套接字句柄) //关闭套接字释放资源
9.网络.关闭() //关闭网络环境释放资源
复制代码
37 TCP/IP协议的使用
下面介绍下TCP/IP服务器、客户端的流程： TCP 服务端创建流程
1、初始化网络环境(网络.初始化())
2、创建套接字(网络.套接字())
3、绑定套接字并开启端口(网络.绑定())
4、监听套接字并设置可同时连接数(网络.监听())
5、接受连接(网络.接受())
6、接收或发送数据(网络.接收()、网络.发送())
7、返回等待另一客户请求(关闭网络.接受()创建的客户端套接字,重新调用网络.接受()创建新的客户端套接字)
8、关闭套接字(网络.关闭套接字())
9、关闭初始化网络环境(网络.关闭())
TCP 客户端创建流程
1、初始化网络环境(网络.初始化())
2、创建套接字(网络.套接字())
3、与服务器建立连接(网络.连接())
4、接收或发送数据(网络.接收()、网络.发送())
5、关闭套接字(网络.关闭套接字())
6、关闭初始化网络环境(网络.关闭())
图解如下：
38
实例代码如下： 服务器代码
1.网络.初始化() //初始化网络环境
2.
整型 服务器套接字句柄=网络.套接字(1) //创建流式(TCP)套接字
3.
网络.绑定(服务器套接字句柄,9999) //开启了计算机的9999端口,供外界连接
4.
网络.监听(服务器套接字句柄,5) //监听套接字,设置可连接数为5个
39 5.
字符型 返回IP,发送缓存=\"客户端,你好,我是服务器\",接收缓存
6.
循环(真) //循环接受处理连接
7.
整型 客户端套接字句柄=网络.接受(服务器套接字句柄,返回IP)//这里程序会挂起等待,直到有客户端连接到来 8.
网络.发送(客户端套接字句柄,发送缓存)//向指定客户端发送一串字符串
9.
网络.接收(客户端套接字句柄,接收缓存) //接收从客户端发送的字串 10.串 11. 网络.关闭套接字(客户端套接字句柄) //关闭套接 辅助.消息框(接收缓存) //打印从客户端接收的字字释放资源 12. 如果(接收缓存==\"关闭\") //客户端如果发送 关闭
服务器将关闭 13.14.15.16.17. 辅助.消息框(\"服务器关闭\") 跳出
如果结束
循环结束
网络.关闭套接字(服务器套接字句柄) //关闭套接字释放资源
18.
复制代码
客户端代码 网络.关闭() //关闭网络环境释放资源
1.网络.初始化() //初始化网络环境
2.整型 客户端套接字句柄=网络.套接字(1) //创建流式(TCP)套接字
3.网络.连接(客户端套接字句柄,\"127.0.0.1\",9999) //这里测试所以连接的是本机
4.字符型 发送缓存=\"服务器,你好,我是客户端\",接收缓存 5.网络.接收(客户端套接字句柄,接收缓存) //接收从服务器发送的字串
40 6.辅助.消息框(接收缓存) //打印从服务器接收的字串
7.网络.发送(客户端套接字句柄,发送缓存)//向指定服务器发送一串字符串
8.网络.关闭套接字(客户端套接字句柄) //关闭套接字释放资源
9.网络.关闭() //关闭网络环境释放资源
复制代码
网络命令的使用范围很广泛，大家可以根据自己的需要加入深入。
41
