欢迎访问 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日