欢迎访问 Forcal程序设计

FORCAL 标准输入输出动态库FcIO

目 录

1 什么是FcIO
2 格式化输入输出函数
io::printf | 格式化输出到标准设备
io::sprintf | 格式化输出到字符串
io::fprintf | 格式化输出到文件
io::sscanf | 从FcData字符串格式化输入
io::nsscanf | 从Forcal静态字符串格式化输入
io::fscanf | 从文件格式化输入
io::setlocale | 设置当前地域的各种要素
io::arrayns | 将Forcal静态字符串中的数据读到实数数组
3 文件系统函数
io::fopen | 打开文件
io::fclose | 关闭文件
io::fwrite | 写文件
io::fread | 读文件
io::fseek | 设置文件指针的位置
io::feof | 判断是否到文件尾
io::fflush | 刷新一个打开的流，将缓冲区中的内容写入文件
io::ftell | 获取文件指针位置
io::rewind | 把文件指针设置回文件的起始位置
io:: |
4 目录操作函数
io::SetCurrentDirectory | 设置工作目录
io::GetCurrentDirectory | 获得工作目录
5 其他函数
io::GetFileName | 选择一个文件名
io:: |
io:: |

1 什么是FcIO [返回页首]

FcIO32W.dll是一个Forcal标准输入输出扩展动态库，主要包含文件操作函数及与目录有关的函数。

在FcIO中的函数是通过二级函数命名空间“io”输出的，所有函数均具有类似“io::fopen(...)”的格式。使用!using("io");可简化FcIO中的函数访问。

FcIO32W.dll需要FcData32W.dll的支持，FcData32W.dll要先于FcIO32W.dll加载。

2 格式化输入输出函数 [返回页首]

[返回页首][整数函数、实数函数] io::printf(FormatStr,x1,x2,... ...)：格式化输出到标准设备

FormatStr：格式串（Forcal静态字符串），可包括文本和下表中的控制码。格式化字符串包括两部分内容：一部分是正常字符，这些字符将按原样输出；另一部分是格式化规定字符，以“%”开始, 后跟一个或几个规定字符用来确定输出内容格式。
x1,x2,... ...：与格式串中的控制代码相匹配的数据项列表。数据项的个数与格式说明的个数一致，格式说明和数据项在顺序上相互对应。
返回值：输出字符数（出错时返回-1）。

运行错误：1：不能将字符串发送到自己的地址；2：字符串太多，无法申请缓冲区；3：内存错误；4：缺少格式串（Forcal静态字符串）；5：缺少数据项；6：非法的字符串指针；7：非法的静态字符串地址；8：无法识别格式串；9：数据项多于格式符；10：格式化输出错误。

函数printf()的格式说明符

说明符 | 描述
%% | 说明一个宽字符“%”
%C | 说明一个宽字符
%d | 说明一个带符号的10进制整数
%e | 说明一个带符号的双精度浮点值，该值是用带小写字母“e”的科学计数法表示的
%E | 说明一个带符号的双精度浮点值，该值是用带大写字母“E”的科学计数法表示的
%f | 说明一个带符号的双精度浮点值
%g | 说明一个带符号的双精度浮点值，该值是用正常方法表示的，或者是用带小写字母“e”的科学计数法表示的
%G | 说明一个带符号的双精度浮点值，该值是用正常方法表示的，或者是用带大写字母“E”的科学计数法表示的
%i | 说明一个带符号的10进制整数
%n | 说明一个数，该数用于接收已写字符的个数
%o | 说明一个无符号的8进制整数（此格式符工作不正常）
%p | 说明一个指针，在32位平台上，指针为一个数的前4个字节
%s | 说明一个FcData字符串，如果指定域宽，域宽最大为99
%S | 说明一个Forcal近程静态字符串，如果指定域宽，域宽最大为99
%u | 说明一个无符号的10进制整数
%x | 说明一个无符号的16进制整数，整数中的字母是用小写字母表示的
%X | 说明一个无符号的16进制整数，整数中的字母是用大写字母表示的

printf格式控制符的完整格式：

printf的格式控制的完整格式：
% - 0 m.n l、h或I64 格式字符
下面对组成格式说明的各项加以说明：
①%：表示格式说明的起始符号，不可缺少。
②-：有-表示左对齐输出，如省略表示右对齐输出。
③0：有0表示指定空位填0,如省略表示指定空位不填。
④m.n：m指域宽，即对应的输出项在输出设备上所占的字符数。n指精度。用于说明输出的实型数的小数位数。为指定n时，隐含的精度为n=6位。
⑤l、h或I64：l对整型指long型，对实型指double型。h用于将整型的格式字符修正为short型。I64用于说明一个64位整数。
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
格式字符
格式字符用以指定输出项的数据类型和输出格式。
①d格式：用来输出十进制整数。有以下几种用法：
%d：按整型数据的实际长度输出。
%md：m为指定的输出字段的宽度。如果数据的位数小于m，则左端补以空格，若大于m，则按实际位数输出。
%ld：输出长整型数据。
②o格式：以无符号八进制形式输出整数。对长整型可以用"%lo"格式输出。同样也可以指定字段宽度用“%mo”格式输出。
例：
printf("%d, %o", -1, -1);
运行结果：-1,177777
程序解析：-1在内存单元中（以补码形式存放）为(1111111111111111)2，转换为八进制数为(177777)8。
③x格式：以无符号十六进制形式输出整数。对长整型可以用"%lx"格式输出。同样也可以指定字段宽度用"%mx"格式输出。
④u格式：以无符号十进制形式输出整数。对长整型可以用"%lu"格式输出。同样也可以指定字段宽度用“%mu”格式输出。
⑤c格式：输出一个字符。
⑥s或S格式：用来输出一个串。有几中用法
%s：例如:printf("%S", "CHINA")输出"CHINA"字符串（不包括双引号）。
%ms：输出的字符串占m列，如字符串本身长度大于m，则突破获m的限制,将字符串全部输出。若串长小于m，则左补空格。
%-ms：如果串长小于m，则在m列范围内，字符串向左靠，右补空格。
%m.ns：输出占m列，但只取字符串中左端n个字符。这n个字符输出在m列的右侧，左补空格。
%-m.ns：其中m、n含义同上，n个字符输出在m列范围的左侧，右补空格。如果n>m，则自动取n值，即保证n个字符正常输出。
⑦f格式：用来输出实数（包括单、双精度），以小数形式输出。有以下几种用法：
%f：不指定宽度，整数部分全部输出并输出6位小数。
%m.nf：输出共占m列，其中有n位小数，如数值宽度小于m左端补空格。
%-m.nf：输出共占n列，其中有n位小数，如数值宽度小于m右端补空格。
⑧e格式：以指数形式输出实数。可用以下形式：
%e：数字部分（又称尾数）输出6位小数，指数部分占5位或4位。
%m.ne和%-m.ne：m、n和”-”字符含义与前相同。此处n指数据的数字部分的小数位数，m表示整个输出数据所占的宽度。
⑨g格式：自动选f格式或e格式中较短的一种输出，且不输出无意义的零。
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
对于单精度数，使用%f格式符输出时，仅前7位是有效数字，小数6位。
对于双精度数，使用%lf格式符输出时，前16位是有效数字，小数6位。

例子：

> io::printf("a=%d\r\n", 123); //输出十进制整数a=123
> io::printf("a=%6d\r\n", 123); //输出6位十进制数a= 123
> io::printf("a=%06d\r\n", 123); //输出6位十进制数a=000123
> io::printf("a=%2d\r\n", 123); //超过2位, 按实际值输出a=123
> io::printf("i=%-6d\r\n", 123); //输出左对齐6位十进制整数i=123
> io::printf("i=%p\r\n", 1111111111111); //输出地址i=211C7000
> io::printf("f=%f\r\n", 3.141593); //输出浮点数f=3.141593
> io::printf("f=%6.4f\r\n", 3.141593); //输出6位其中小数点后4位的浮点数f=3.1416
> io::printf("x=%lf\r\n", 0.123457); //输出长浮点数x=0.123457
> io::printf("x=%18.16lf\r\n", 0.1234567898765432);//输出18位其中小数点后16位的长浮点x=0.1234567898765432
> io::printf("c=%C\r\n", 66); //输出字符c=B
> io::printf("s=%S\r\n", "hello！您好！"); //输出数组字符串s=hello！您好！
> io::printf("X=%X\r\n", 1234567890123456789); //输出16进制整数X=7DE98100
> io::printf("X=%I64X\r\n", 1234567890123456789); //输出16进制整数X=112210F47DE98100

[返回页首][整数函数、实数函数] io::sprintf(str,FormatStr,x1,x2,... ...)：格式化输出到字符串

str：FcData字符串指针。所有输出将保存到该字符串。
FormatStr：格式串（Forcal静态字符串），可包括文本和控制码。格式化字符串包括两部分内容：一部分是正常字符，这些字符将按原样输出；另一部分是格式化规定字符，以“%”开始, 后跟一个或几个规定字符用来确定输出内容格式。
x1,x2,... ...：与格式串中的控制代码相匹配的数据项列表。数据项的个数与格式说明的个数一致，格式说明和数据项在顺序上相互对应。
返回值：输出字符数（出错时返回-1）。

运行错误：1：非法的FcData字符串指针str；2：str应是一维字符数组；3：不能将字符串发送到自己的地址；4：字符串太多，无法申请缓冲区；5：内存错误；6：缺少格式串（Forcal静态字符串）；7：缺少数据项；8：非法的字符串指针；9：非法的静态字符串地址；10：无法识别格式串；11：数据项多于格式符；12：格式化输出错误。

说明：该函数功能与 printf 类似，仅将输出定向到字符串，请参考 printf 的说明。

例子：

> i:(:s)= s=new[string,100,EndType,""],io::sprintf(s,"a=%06d\r\n", 123),io::printf["%s",s],delete[s]; //输出6位十进制数a=000123

[返回页首][整数函数、实数函数] io::fprintf(pfile,FormatStr,x1,x2,... ...)：格式化输出到文件

pfile：文件句柄。所有输出将保存到该文件。
FormatStr：格式串（Forcal静态字符串），可包括文本和控制码。格式化字符串包括两部分内容：一部分是正常字符，这些字符将按原样输出；另一部分是格式化规定字符，以“%”开始, 后跟一个或几个规定字符用来确定输出内容格式。
x1,x2,... ...：与格式串中的控制代码相匹配的数据项列表。数据项的个数与格式说明的个数一致，格式说明和数据项在顺序上相互对应。
返回值：输出字符数（出错时返回-1）。

运行错误：1：非法的文件句柄；2：文件没有打开；3：缺少格式串（Forcal静态字符串）；4：缺少数据项；5：非法的FcData字符串指针；6：非法的静态字符串地址；7：无法识别格式串；8：数据项多于格式符；9：格式化输出错误。

说明：该函数功能与 printf 类似，仅将输出定向到文件，请参考 printf 的说明。

例子：

> !using["io"];
> i:a(::f,d) = f=new[file],d=new[string,EndType,"您好！\r\nhello!\r\n"];
> i:b(::f) = fopen[f,"aa.txt","wb+"];
> i:c(::f,d) = fwrite[f,NULL,2,UTEXT],fprintf(f,"a=%06d\r\n%s", 123,d);
> i:d(::f,x,e) = e=new[string,(ftell(f)-1)/2],rewind[f],fread[f,NULL,2,x],fread[f,e];
> i:e(::f,e) = printf["\r\n%s\r\n",e];
> i:f(::f) = fclose[f];
> i:g(::f,d,e) = delete[f],delete[d],delete[e];

[返回页首][整数函数、实数函数] io::sscanf(str,FormatStr,&x1,&x2,... ...)：从FcData字符串格式化输入

str：FcData字符串指针。所有数据将从该字符串读取。
FormatStr：格式串（Forcal静态字符串），可包括文本和控制码。格式化字符串包括两部分内容：一部分是正常字符 ，另一部分是格式化规定字符，以“%”开始, 后跟一个或几个规定字符用来确定输出内容格式。
&x1,&x2,... ...：与格式串中的控制代码相匹配的数据项列表。数据项的个数与格式说明的个数一致，格式说明和数据项在顺序上相互对应。
返回值：返回成功地处理的数据项的个数（出错时返回-1）。在此例中，若仅读取了x1，返回3；若处理到x2，返回4；以此类推。

运行错误：1：源字符串不存在；2：缺少格式串（Forcal静态字符串）；3：缺少数据项；4：非法的FcData字符串指针；5：源字符串与目的字符串相同，无法操作；6：内存错误；7：非法的静态字符串地址；8：静态字符串缓冲区太小；9：无法识别格式串；10：数据项多于格式符 。

函数sscanf()的格式说明符

说明符 | 描述
%& | 说明一个相对于源字符串的偏移量，将从该位置从字符串中读取数据。该说明符仅用于格式串的开头。该说明符仅用于sscanf()和nsscanf()函数
%% | 说明一个宽字符“%”
%C | 说明一个宽字符
%d | 说明一个带符号的10进制整数
%e | 说明一个带符号的双精度浮点值，该值是用带小写字母“e”的科学计数法表示的
%E | 说明一个带符号的双精度浮点值，该值是用带大写字母“E”的科学计数法表示的
%f | 说明一个带符号的双精度浮点值
%g | 说明一个带符号的双精度浮点值，该值是用正常方法表示的，或者是用带小写字母“e”的科学计数法表示的
%G | 说明一个带符号的双精度浮点值，该值是用正常方法表示的，或者是用带大写字母“E”的科学计数法表示的
%i | 说明一个带符号的10进制整数
%n | 说明一个数，该数用于接收已读字符的个数。在函数fscanf()中，该数用于接收当前的文件指针位置
%o | 说明一个无符号的8进制整数（此格式符工作不正常）
%p | 说明一个指针，在32位平台上，指针为一个数的前4个字节
%s | 说明一个FcData字符串
%S | 说明一个Forcal近程静态字符串。需要2个参数，第一个参数指出该字符串，第二个参数指出该字符串缓冲区的大小
%u | 说明一个无符号的10进制整数
%x | 说明一个无符号的16进制整数，整数中的字母是用小写字母表示的
%X | 说明一个无符号的16进制整数，整数中的字母是用大写字母表示的

sscanf 格式控制符的完整格式：{%[*] [width] [{h | l | I64 | L}]type | 非%符号}

说明：

1、* 亦可用于格式中, (即 %*d 和 %*s) 加了星号 (*) 表示跳过此数据不读入(也就是不把此数据读入参数中) 。
2、{a|b|c}表示a,b,c中选一，[d],表示可以有d也可以没有d。
3、width表示读取宽度。
4、{h | l | I64 | L}:参数的size,通常h表示单字节size，I表示2字节 size,L表示4字节size(double例外),l64表示8字节size。
5、type :这就很多了，就是%s,%d之类。
6、特别的：%*[width] [{h | l | I64 | L}]type 表示满足该条件的被过滤掉，不会向目标参数中写入值

支持集合操作：

%[a-z] 表示匹配a到z中任意字符，贪婪性(尽可能多的匹配)，存放到FcData字符串
%[aB'] 匹配a、B、'中一员，贪婪性，存放到FcData字符串
%[^a] 匹配非a的任意字符，贪婪性，存放到FcData字符串

%<a-z> 表示匹配a到z中任意字符，贪婪性(尽可能多的匹配)，存放到Forcal近程静态字符串
%<aB'> 匹配a、B、'中一员，贪婪性，存放到Forcal近程静态字符串
%<^a> 匹配非a的任意字符，贪婪性，存放到Forcal近程静态字符串

例子1：读一个字符串

> !using["io"];
> i:a(::s,buf) = s=new[string,EndType,"您好！\r\nhello!\r\n"],buf=new[string,80];
> i:b(::s,buf) = sscanf(s, "%s", buf); //读第1个字符串
> i:c(::buf) = printf["\r\n%s\r\n\r\n",buf];
> i:d(::s,buf) = sscanf(s, "%*s%s",buf); //读第2个字符串
> i:e(::buf) = printf["\r\n%s\r\n\r\n",buf];
> i:f(::s,buf) = sscanf(s, "%&%s",1,buf); //从第2个字符开始读
> i:g(::buf) = printf["\r\n%s\r\n\r\n",buf];
> i:h(::s,buf) = delete[s],delete[buf];

[返回页首][整数函数、实数函数] io::nsscanf(str,FormatStr,&x1,&x2,... ...)：从Forcal静态字符串格式化输入

str：Forcal近程静态字符串。所有数据将从该字符串读取。
FormatStr：格式串（Forcal静态字符串），可包括文本和控制码。格式化字符串包括两部分内容：一部分是正常字符 ，另一部分是格式化规定字符，以“%”开始, 后跟一个或几个规定字符用来确定输出内容格式。
&x1,&x2,... ...：与格式串中的控制代码相匹配的数据项列表。数据项的个数与格式说明的个数一致，格式说明和数据项在顺序上相互对应。
返回值：返回成功地处理的数据项的个数（出错时返回-1）。在此例中，若仅读取了x1，返回3；若处理到x2，返回4；以此类推。

运行错误：1：源字符串不存在；2：缺少格式串（Forcal静态字符串）；3：缺少数据项；4：非法的FcData字符串指针；5：源字符串与目的字符串相同，无法操作；6：内存错误；7：非法的静态字符串地址；8：静态字符串缓冲区太小；9：无法识别格式串；10：数据项多于格式符 。

说明：该函数功能与 sscanf 类似， 但从Forcal近程静态字符串中读取数据，请参考 sscanf 的说明。

例子1：读一个字符串

> !using["io"];
> i:a(::buf) = buf=new[string,80];
> i:b(::buf) = nsscanf("您好！ hello!", "%s", buf); //读第1个字符串
> i:c(::buf) = printf["\r\n%s\r\n\r\n",buf];
> i:d(::buf) = nsscanf("您好！ hello!", "%*s%s",buf); //读第2个字符串
> i:e(::buf) = printf["\r\n%s\r\n\r\n",buf];
> i:f(::buf) = nsscanf("您好！ hello!", "%&%s",1,buf); //从第2个字符开始读
> i:g(::buf) = printf["\r\n%s\r\n\r\n",buf];
> i:h(::buf) = delete[buf];

例子2：取指定长度的字符串。如在下例中，取最大长度为4字节的字符串。

> a(:a) = io::nsscanf("123456 6666", "%4S", a="\[80]",80),io::printf["\r\n%S\r\n\r\n",a];

例子3：取到指定字符为止的字符串。如在下例中，取遇到空格为止字符串。

> a(:a) = io::nsscanf("123456 abcdedf", "%<^ >", a="\[80]",80),io::printf["\r\n%S\r\n\r\n",a];

例子4：取仅包含指定字符集的字符串。如在下例中，取仅包含1到9和小写字母的字符串。

> a(:a) = io::nsscanf("123456abcdedfBCDEF", "%<1-9a-z>", a="\[80]",80),io::printf["\r\n%S\r\n\r\n",a];

例子5：取到指定字符集为止的字符串。如在下例中，取遇到大写字母为止的字符串。

> a(:a) = io::nsscanf("123456abcdedfBCDEF", "%<^A-Z>", a="\[80]",80),io::printf["\r\n%S\r\n\r\n",a];

例子6：给定一个字符串iios/12DDWDFF@122，获取 / 和 @ 之间的字符串，先将 "iios/"过滤掉，再将非'@'的一串内容送到字符串缓冲区中。

> a(:a) = io::nsscanf("iios/12DDWDFF@122", "%*[^/]/%<^@>", a="\[80]",80),io::printf["\r\n%S\r\n\r\n",a];

例子7：浮点数读取。

> a(:a,b) = io::nsscanf(" 12.3 56.7", "%le%le", &a,&b),io::printf["\r\n%e\r\n%e\r\n",a,b];
> a(:a,b) = io::nsscanf(" 12.3, 56.7", "%le,%le", &a,&b),io::printf["\r\n%e\r\n%e\r\n",a,b];

[返回页首][整数函数、实数函数] io::fscanf(pfile,FormatStr,&x1,&x2,... ...)：从文件格式化输入

pfile：文件句柄。将从该文件 中读取格式化数据。
FormatStr：格式串（Forcal静态字符串），可包括文本和控制码。格式化字符串包括两部分内容：一部分是正常字符 ，另一部分是格式化规定字符，以“%”开始, 后跟一个或几个规定字符用来确定输出内容格式。
&x1,&x2,... ...：与格式串中的控制代码相匹配的数据项列表。数据项的个数与格式说明的个数一致，格式说明和数据项在顺序上相互对应。
返回值：返回成功地处理的数据项的个数（出错时返回-1）。在此例中，若仅读取了x1，返回3；若处理到x2，返回4；以此类推。

运行错误：1：源字符串不存在；2：缺少格式串（Forcal静态字符串）；3：缺少数据项；4：非法的FcData字符串指针；5：源字符串与目的字符串相同，无法操作；6：内存错误；7：非法的静态字符串地址；8：静态字符串缓冲区太小；9：无法识别格式串；10：数据项多于格式符 。

说明：该函数功能与 sscanf 类似， 但从文件中读取数据，请参考 sscanf 的说明。

例子1：读一个字符串

> !using["io"];
> i:a(::buf,f) = buf=new[string,80],f=new[file],fopen[f,"aa.txt","rb"]; //Unicode文件“aa.txt”要预先存在
> i:b(::buf,f) = fread[f,NULL,2,0],fscanf(f, "%s", buf); //读第1个字符串
> i:c(::buf) = printf["\r\n%s\r\n\r\n",buf];
> i:d(::buf,f) = rewind[f],fread[f,NULL,2,0],fscanf(f, "%*s%s",buf); //读第2个字符串
> i:e(::buf) = printf["\r\n%s\r\n\r\n",buf];
> i:f(::buf,f) = fseek[f,6,SEEK_SET],fscanf(f, "%s",1,buf); //从第3个字符开始读
> i:g(::buf) = printf["\r\n%s\r\n\r\n",buf];
> i:h(::buf,f) = delete[f],delete[buf];

[返回页首][整数函数、实数函数] io::setlocale(category,locale,str,len)：设置当前地域的各种要素

category：要被修改的地域要素。只能取LC_ALL（设置所有类别）、LC_COLLATE（设置与函数strcoll()等相关联的地域类别）、LC_CTYPE（设置与宽字符关联的地域类别）、LC_MONETARY（设置影响内存格式的地域类别）、LC_NUMERIC（设置影响小数点的地域类别）和LC_TIME（设置影响时间函数的地域类别）。
locale：地域名Forcal静态字符串。
str：Forcal静态字符串地址，用于接收原先的地域字符串。
len：Forcal静态字符串缓冲区长度。
返回值：返回str。如果字符串缓冲区太小，仅接收部分地域字符串，且返回-1。

运行错误：1：非法的字符串地址。

[返回页首][实数函数] io::arrayns(array,str,&k)：将Forcal静态字符串中的数据读到实数数组

array：双精度实数数组指针。
str：Forcal静态字符串地址，包含若干数字字符串。
k： 数组起始地址，将从该地址存放数据。返回时k指向下一个元素的地址。可以缺省该参数，此时将从地址0开始存放数据。
返回值：返回array。

运行错误：1： 参数太多或者太少；2：非法的实数数组指针；3：非法的Forcal静态字符串地址；4：非法的数组起始地址；5：非法的数字字符串。

例子：

> i: OutVector(p:k,i)= k=FCDLen(p),printff{"\r\n"},i=0,(i<k).while{printff{"{1,r,14.6}",get[p,i]},i++},printff{"\r\n"}; //输出一维数组
> (:i,k)=
> {
> k=1,
> i=new[rtoi(real_s),rtoi(5),rtoi(EndType):1.1,2.2,3.3,4.4,5.5].io::arrayns["1,2,3",&k],
> OutVector[i],
> delete[i],k
> };

3 文件系统函数 [返回页首]

在操作文件时，首先要申请一个文件句柄：hFile=new(io::file)，然后打开文件、读写文件、关闭文件等都是针对文件句柄hFile进行的，文件句柄不用时，最后要用函数delete销毁它：delete(hFile)。如果文件没有关闭，在销毁文件句柄时，会自动关闭打开的文件。

[返回页首][整数函数、实数函数] io::fopen(hFile,"filename","mode")： 打开文件

hFile：文件句柄。用new(io:file)申请。
"filename"：文件名，可以包含路径和文件名两部分。
"mode"：打开文件的类型。关于文件类型的规定参见下面说明。
返回值：操作成功，返回有效的文件句柄hFile。否则返回0。无需检查操作是否成功，相应的文件操作函数会自动进行检查。

运行错误：1：非法的文件句柄；2：文件正在使用，尚未关闭；3：需要字符串参数指出文件名和文件访问模式；4：文件访问模式错误。

说明：

>     文件名格式：

>     	"B:TEST.DAT"
>     	"C:\\TC\\TEST.DAT"

>     注意：如果将路径写成"C:\TC\TEST.DAT"是不正确的, 这一点要特别注意。

>     fopen函数用来打开一个文件，其调用的一般形式为：fopen(文件句柄,文件名,使用文件方式)
>      其中，“文件句柄”必须是用new(io:file)申请，“文件名”是被打开文件的文件名。
>     “使用文件方式”是指文件的类型和操作要求。“文件名”是字符串常量或字符串数组。例如：
>     	fopen(hFile,"file a","r");
>     其意义是在当前目录下打开文件file a，只允许进行“读”操作。
>     又如：
>     	fopen(hFile,"c:\\hzk16","rb")
>     其意义是打开C驱动器磁盘的根目录下的文件hzk16， 这是一个二进制文件，只允许按二进制方式进行读操作。
>     两个反斜线“\\ ”中的第一个表示转义字符，第二个表示根目录。使用文件的方式共有12种，下面给出了它们的符号和意义。

>                        表 文件操作类型

>     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━

>           字符                 含义

>     ────────────────────────────

>            "r"            打开文字文件只读

>            "w"            创建文字文件只写

>            "a"            增补, 如果文件不存在则创建一个

>            "r+"           打开一个文字文件读/写

>            "w+"           创建一个文字文件读/写

>            "a+"           打开或创建一个文件增补

>            "b"            二进制文件(可以和上面每一项合用)

>            "t"            文这文件(默认项)

>     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━

>     文件使用方式 　　　　　　　意 义

>     "rt"　　　　　　只读打开一个文本文件，只允许读数据
>     "wt"　　　　　　只写打开或建立一个文本文件，只允许写数据
>     "at"　　　　　　追加打开一个文本文件，并在文件末尾写数据
>     "rb"　　　　　　只读打开一个二进制文件，只允许读数据
>     "wb"　　　　 　 只写打开或建立一个二进制文件，只允许写数据
>     "ab" 　　　　 　追加打开一个二进制文件，并在文件末尾写数据
>     "rt+"　　　　　 读写打开一个文本文件，允许读和写
>     "wt+"　　　　　 读写打开或建立一个文本文件，允许读写
>     "at+"　　　　　 读写打开一个文本文件，允许读，或在文件末追加数据
>     "rb+"　　　　　 读写打开一个二进制文件，允许读和写
>     "wb+"　　　　　 读写打开或建立一个二进制文件，允许读和写
>     "ab+" 　　　　　读写打开一个二进制文件，允许读，或在文件末追加数据

>     对于文件使用方式有以下几点说明：

>     1. 文件使用方式由r,w,a,t,b，+六个字符拼成，各字符的含义是：

>     	r(read): 读
>     	w(write): 写
>     	a(append): 追加
>     	t(text): 文本文件，可省略不写
>     	b(banary): 二进制文件
>     	+: 读和写

>     2. 凡用"r"打开一个文件时，该文件必须已经存在，且只能从该文件读出。

>     3. 用"w"打开的文件只能向该文件写入。 若打开的文件不存在，则以指定的文件名建立该文件，若打开的文件已经存在，则将该文件删去，重建一个新文件。

>     4. 若要向一个已存在的文件追加新的信息，只能用"a "方式打开文件。但此时该文件必须是存在的，否则将会出错。

>     5. 在打开一个文件时，如果出错，fopen将返回一个空指针值NULL给文件句柄hFile，后续文件操作将不能正常进行。

>     6. 把一个文本文件读入内存时，要将ASCII码转换成二进制码，而把文件以文本方式写入磁盘时，也要把二进制码转换成ASCII码，因此文本文件的读写要花费较多的转换时间。

>     7. 对二进制文件的读写不存在转换。

>     8. Unicode文本文件的标志是：文件长度是偶数，首字符为io::UTEXT（该字符仅是一个标志，不包括在有效的Unicode文本文件内容中）。

>     如果要打开一个CCDOS子目录中, 文件名为CLIB的二进制文件, 可写成:

>     	fopen(hFile,"c:\\ccdos\\clib", "rb");

[例子1] 读Unicode文本文件（以起始字符 UTEXT 为标志）并显示其内容，表达式之间用模块变量传递参数

> !using["io"]; //使用命名空间“io”
> i:a(::f) = f=new[file]; //申请文件句柄
> i:b(::f) = fopen[f,"aa.txt","rb"]; //打开文件，"aa.txt"必须是已经存在的Unicode文本文件
> i:c(::f) = fseek(f,0,SEEK_END); //把文件指针移动到文件末尾，记得显示文件内容时要把指针移动回到文件头部
> i:d(::f,len) = len=ftell[f]; //获取文件指针的位置，相当于得到文件的长度了
> i:e(::len,s) = s=new[string,len+1]; //根据文件长度申请内存空间，使读取文件长度获得一定的灵活性，注意后面加一的意义
> i:f(::f) = rewind[f]; //把文件指针移动到文件开头，当然也可以用fseek()完成这个动作
> i:g(::f,x,s) = fread[f,NULL,2,x]; //读取第一个字符，若为Unicode文本文件，该字符应为UTEXT，可以进行判断，这里省略了
> i:h(::f,x,s) = fread[f,s]; //读取文件
> i:i(::f) = fclose[f]; //关闭文件
> i:j(::s) = printff["{1,s}\r\n",s]; //输出文件内容
> i:k(::f,s) = delete[f],delete[s]; //销毁文件句柄及字符串

[例子2] 二进制文件读写

> !using["io"];
> i:a(::f,d,e) = f=new[file],d=new[int_s,5,EndType,1,2,3,4,5],e=new[int_s,5,EndType,0,0,0,0,0];
> i:b(::f,d,e) = fopen[f,"aa.txt","wb+"];
> i:c(::f,d,e) = fwrite[f,d],rewind[f],fread[f,e];
> i:d(::f,d,e) = printff["{1,i,5}{2,i,5}{3,i,5}{4,i,5}{5,i,5}\r\n",e.get[0],e.get[1],e.get[2],e.get[3],e.get[4]];
> i:e(::f,d,e) = fclose[f];
> i:f(::f,d,e) = delete[f],delete[d],delete[e];

[例子3] Unicode文本文件读写，用二进制文件实现

> !using["io"];
> i:a(::f,d,e) = f=new[file],d=new[string,80,EndType,"hello!\r\nForcal"],e=new[string,80];
> i:b(::f) = fopen[f,"aa.txt","wb+"];
> i:c(::f,d) = fwrite[f,NULL,2,UTEXT],fwrite[f,d,d.FCDstrlen()];
> i:d(::f,x,e) = rewind[f],fread[f,NULL,2,x],fread[f,e];
> i:e(::f,e) = printff["{1,s}\r\n",e];
> i:f(::f) = fclose[f];
> i:g(::f,d,e) = delete[f],delete[d],delete[e];

[返回页首][整数函数、实数函数] io::fclose(hFile)： 关闭文件
hFile：文件句柄。
返回值：操作成功，返回0。否则返回io::EOF。
说明：该函数仅关闭文件，并没有销毁文件句柄（用delete(hFile)销毁文件句柄），还可以再次用fopen打开文件。

[返回页首][整数函数、实数函数] io::fwrite(hFile,buffer)或io::fwrite(hFile,buffer,count)或io::fwrite(hFile,NULL,Size,num)： 写文件

hFile：文件句柄。
buffer：FcData数据指针（类指针除外），如果buffer是一个数组，将写数组的全部数据，或者count指定的数据数目。
count：写入数据的最大数目。
Size：数据标志。Size=0表示字符串（Unicode字符串，Forcal默认字符串）；Size=1表示8位整数（如int8或char）；Size=2表示16位整数（如int16或wchar）；Size=4表示32位整数（如int32）；Size=8表示64位整数（如int64或real64）；Size=8表示64位整数（如int64或real64）。Size等于其他值是非法的。
num：当Size=0时，num是一个Forcal近程静态字符串地址；否则num是一个数，数的类型取决于Size。
返回值：返回写入的数据对象的数目。

运行错误：1：至少需要2个参数；2：非法的文件指针；3：文件没有打开；4：非法的FcData指针；5：字符串地址非法；6：非法的数据标志；7：参数不符合要求，太多。

[返回页首][整数函数、实数函数] io::fread(hFile,buffer)或io::fread(hFile,buffer,count)或io::fread(hFile,NULL,Size,num)或io::fread(hFile,NULL,NULL,num,strmax)：读文件

hFile：文件句柄。
buffer：FcData数据指针（类指针除外），如果buffer是一个数组，将读数组的全部数据，或者count指定的数据数目。
count：读入数据的最大数目。
Size：数据标志。Size=0表示字符串（Unicode字符串，Forcal默认字符串）；Size=1表示8位整数（如int8或char）；Size=2表示16位整数（如int16或wchar）；Size=4表示32位整数（如int32）；Size=8表示64位整数（如int64或real64）；Size=8表示64位整数（如int64或real64）。Size等于其他值是非法的。
num：当Size=0时，num是一个Forcal近程静态字符串地址；否则num是一个数，数的类型取决于Size。
strmax：当Size=0时，使用该参数，strmax是一个Forcal近程静态字符串缓冲区的大小。
返回值：返回读取的数据对象的数目。

运行错误：1：至少需要2个参数；2：非法的文件指针；3：文件没有打开；4：非法的FcData指针；5：字符串地址非法；6：非法的数据标志；7：参数不符合要求，太多。

[返回页首][整数函数、实数函数] io::fseek(hFile,offset,origin)： 设置文件指针的位置

hFile：文件句柄。
offset：文件指针从origin开始的偏移字节数。
origin：起始位置，函数从该位置开始增加偏移量。只能取io::SEEK_CUR（当前位置），io::SEEK_END（文件尾）和io::SEEK_SET（文件头）。
返回值：成功时返回0，否则返回非0值。

运行错误：1：非法的起始位置；2：文件没有打开；3：非法的文件句柄。

[返回页首][整数函数、实数函数] io::feof(hFile)： 判断是否到文件尾

hFile：文件句柄。
返回值：没有到达文件尾时返回0，否则返回非0值。

运行错误：1：文件没有打开；2：非法的文件句柄。

[返回页首][整数函数、实数函数] io::fflush(hFile)：刷新一个打开的流 ，将缓冲区中的内容写入文件

hFile：文件句柄。
返回值：操作成功，返回0。否则返回io::EOF。

运行错误：1：文件没有打开；2：非法的文件句柄。

[返回页首][整数函数、实数函数] io::ftell(hFile)：获取文件指针位置

hFile：文件句柄。
返回值：操作失败返回-1。

运行错误：1：文件没有打开；2：非法的文件句柄。

[返回页首][整数函数、实数函数] io::rewind(hFile)：把文件指针设置回文件的起始位置

hFile：文件句柄。
返回值：0。

运行错误：1：文件没有打开；2：非法的文件句柄。

4 目录操作函数 [返回页首]

[返回页首][整数函数、实数函数] io::SetCurrentDirectory("c:\\My Documents")：设置工作目录

注意字符串中两个反斜杠\\被解释为一个反斜杠\，如上例。
该函数可能返回如下运行错误：1：指定的字符串不存在。

[返回页首][整数函数、实数函数] io::GetCurrentDirectory(length,buf)：获得工作目录

length：缓冲区大小。
buf：缓冲区，Forcal近程静态字符串地址。
返回值：函数调用成功，返回写到缓冲区的字符串数目；函数调用失败，返回值为0。若缓冲区太小，返回需要的缓冲区大小。

运行错误：1：非法的缓冲区地址或者缓冲区长度不符合要求。

[例子] (:str)=io::GetCurrentDirectory(200,str="\[200]"),FcWin::MessageBox[str,32];

5 其他函数 [返回页首]

[返回页首][整数函数、实数函数] io::GetFileName(str,len,Note)：选择一个文件名
str：Forcal近程静态字符串地址， 存放文件名的缓冲区，长度不小于MAX_PATH（260）。
len：缓冲区大小，不小于MAX_PATH（260）。
Note：Forcal字符串地址，显示到打开文件对话框的标题栏中。可缺省此参数。
返回值：用户进行选择时返回1，未选返回0。

运行错误：1：参数不符合要求；2： 非法的缓冲区地址或者缓冲区长度不符合要求。

[例子] (:str)=io::GetFileName(str="\[261]",261,"请选择一个文件名，或者输入一个文件名"),FcWin::MessageBox[str,32];

版权所有© Forcal程序设计 2002-2010，保留所有权利
E-mail: forcal@sina.com QQ：630715621
最近更新: 2010年01月23日