setjmp()的返回值和longjmp的第二个参数是不是同一个变量?

fsegsklk 2014-04-01 05:32:49
看书上貌似longjmp设置了第二个参数后,setjmp的返回值就自动变成那个值了
...全文
81 3 打赏 收藏 转发到动态 举报
写回复
用AI写文章
3 条回复
切换为时间正序
请发表友善的回复…
发表回复
qq120848369 2014-04-01
  • 打赏
  • 举报
回复
longjmp第二个参数就是setjmp的返回值,但不能传0,如果传0则被修正为1. 自己学会看man page:man longjmp
fsegsklk 2014-04-01
  • 打赏
  • 举报
回复
你的帮助文档似乎并没有说明我的问题啊,而且残缺不全
JiMoKuangXiangQu 2014-04-01
  • 打赏
  • 举报
回复
  Platform Builder for Microsoft Windows CE 5.0    

setjmpSee Also
longjmp | _fpreset

Requirements
OS Versions: Windows CE 2.0 and later.
Header: stdlib.h.
Link Library: coredll.dll.
Saves the current state of the program.

int setjmp( 
  jmp_buf env 
);
Parameters
env 
Variable in which environment is stored. 
Libraries
All versions of the C run-time libraries.

Return Values
setjmp returns 0 after saving the stack environment. If setjmp returns as a result of a longjmp call, it returns the value argument of longjmp, or if the value argument of longjmp is 0, setjmp returns 1. There is no error return.

Remarks
The setjmp function saves a stack environment, which you can subsequently restore using longjmp. When used together, setjmp and longjmp provide a way to execute a non-local goto. They are typically used to pass execution control to error-handling or recovery code in a previously called routine without using the normal calling or return conventions.

A call to setjmp saves the current stack environment in env. A subsequent call to longjmp restores the saved environment and returns control to the point just after the corresponding setjmp call. All variables (except register variables) accessible to the routine receiving control contain the values they had when longjmp was called.

setjmp and longjmp do not support C++ object semantics. In C++ programs, use the C++ exception-handling mechanism. Using the longjmp or setjmp run-time routines in a C++ program will generate a link error if C++ exceptions are enabled using the /GX-Enable Exception Handling compiler option.

Requirements
OS Versions: Windows CE 2.0 and later.
Header: stdlib.h.
Link Library: coredll.dll.

See Also
longjmp | _fpreset




--------------------------------------------------------------------------------

Last updated on Wednesday, September 14, 2005

© 2005 Microsoft Corporation. All rights reserved.
  Platform Builder for Microsoft Windows CE 5.0    

longjmpSee Also
setjmp

Requirements
OS Versions: Windows CE 2.0 and later.
Header: stdlib.h.
Link Library: coredll.dll.
Restores stack environment and execution locale.

void longjmp( 
   jmp_buf env, 
   int value 
);
Parameters
env 
Variable in which environment is stored. 
value 
Value to be returned to setjmp call. 
Return Values
None.

Remarks
The longjmp function restores a stack environment and execution locale previously saved in env by setjmp. 

setjmp and longjmp provide a way to execute a nonlocal goto; they are typically used to pass execution control to error-handling or recovery code in a previously called routine without using the normal call and return conventions.

A call to setjmp causes the current stack environment to be saved in env. A subsequent call to longjmp restores the saved environment and returns control to the point immediately following the corresponding setjmp call. Execution resumes as if value had just been returned by the setjmp call. 

The values of all variables (except register variables) that are accessible to the routine receiving control contain the values they had when longjmp was called. 

The values of register variables are unpredictable. The value returned by setjmp must be nonzero. If value is passed as 0, the value 1 is substituted in the actual return.

Call longjmp before the function that called setjmp returns; otherwise the results are unpredictable.

Observe the following restrictions when using longjmp: 

Do not assume that the values of the register variables will remain the same. The values of register variables in the routine calling setjmp may not be restored to the proper values after longjmp is executed. 
Do not use longjmp to transfer control out of an interrupt-handling routine unless the interrupt is caused by a floating-point exception. In this case, a program may return from an interrupt handler via longjmp if it first reinitializes the floating-point math package by calling _fpreset. 
Be careful when using setjmp and longjmp in C++ programs. Because these functions do not support C++ object semantics, it is safer to use the C++ exception-handling mechanism. 
Using the longjmp or setjmp C runtime routines in a C++ file will generate a link error if C++ exceptions are enabled by using the /GX - Enable Exception Handling compiler option. This behavior is by design in Windows CE. 
Requirements
OS Versions: Windows CE 2.0 and later.
Header: stdlib.h.
Link Library: coredll.dll.

See Also
setjmp




--------------------------------------------------------------------------------

Last updated on Wednesday, September 14, 2005

© 2005 Microsoft Corporation. All rights reserved.

我想帮助文档总比我的描述更妥当。希望对LZ有所帮助。
C 语言编程常见问题解答 【作者】[美]Paul S.R. Chisholm 译:张芳妮 吕 波 【出版社】清华大学出版社 C语言编程常见问题解答(目录) 第l章 C语言 1. 1 什么是局部程序块(local block)? 1. 2 可以把变量保存在局部程序块中吗? 1. 3 什么时候用一条switch语句比用多条if语句更好? 1. 4 switch语句必须包含default分支吗? 1. 5 switch语句的最后—个分支可以不要break语句吗? 1. 6 除了在for语句中之外,在哪些情况下还要使用逗号运算? 1. 7 怎样才能知道循环是否提前结束了? 1. 8 goto,longjmp()和setjmp()之间有什么区别? 1. 9 什么是左值(lvaule)? 1. 10 数组(array)可以是左值吗? 1. 11 什么是右值(rvaule)? 1. 12 运算符的优先级总能保证是“自左至右”或“自右至左”的顺序吗? 1. 13 ++var和var++有什么区别? 1. 14 取模运算符(modulusoperator)“%”的作用是什么? 第2章 变量和数据存储 2. 1 变量存储在内存(memory)中的什么地方? 2. 2 变量必须初始化吗? 2. 3 什么是页抖动(pagethrashing)? 2. 4 什么是const指针? 2. 5 什么时候应该使用register修饰符?它真的有用吗? 2. 6 什么时候应该使用volatile修饰符? 2. 7 一个变量可以同时被说明为const和volatile吗? 2. 8 什么时候应该使用const修饰符? 2. 9 浮点数比较(floating—point comparisons)的可靠性如何? 2. 10 怎样判断一个数字型变量可以容纳的最大值? 2. 11 对不同类型的变量进行算术运算会有问题吗? 2. 12 什么是运算符升级(operator promotion)? 2. 13 什么时候应该使用类型强制转换(typecast)? 2. 14 什么时候不应该使用类型强制转换(typecast)? 2. 15 可以在头文件中说明或定义变量吗? 2. 16 说明一个变量和定义一个变量有什么区别? 2. 17 可以在头文件中说明static变量吗? 2.18 用const说明常量有什么好处? 第3章 排序与查找 排 序 查 找 排序或查找的性能 3.1 哪一种排序方法最方便? 3.2 哪一种排序方法最快? 3.3 当要排序的数据集因太大而无法全部装入内存时,应怎样排序? 3.4 哪一种查找方法最方便? 3.5 哪一种查找方法最快? 3.6 什么是哈希查找? 3.7 怎样对链表进行排序? 3.8 怎样查找链表中的数据? 第4章 数据文件 4.1 当errno为一个非零值时,是否有错误发生? 4.2 什么是流(stream)? 4.3 怎样重定向—个标准流? 4.4 怎样恢复一个重定向了的标准流? 4.5 stdout能被强制打印到非屏幕设备上吗? 4.6 文本模式(text mode)和二进制模式(binary mode)有什么区别? 4.7 怎样判断是使用流函数还是使用低级函数? 4.8 怎样列出某个目录下的文件? 4.9 怎样列出—个文件的日期和时间? 4.10 怎样对某个目录下的文件名进行排序? 4.1l 怎样判断一个文件的属性? 4.12 怎样查看PATH环境变量? 4.13 怎样打开一个同时能被其它程序修改的文件? 4.14 怎样确保只有你的程序能存取一个文件? 4.15 怎样防止其它程序修改你正在修改的那部分文件内容? 4.16 怎样—次打开20个以上的文件? 4.17 怎样避开"Abort,Retry,Fail"消息? 4.18 怎样读写以逗号分界的文本? 第5章 编译预处理 5.1 什么是宏(macro)?怎样使用宏? 5.2 预处理程序(preprocessor)有什么作用? 5.3 怎样避免多次包含同—个头文件? 5.4 可以用#include指令包含类型名不是“.h”的文件吗? 5.5 用#define指令说明常量有什么好处? 5.6 用enum关键字说明常量有什么好处? 5.7 与用#define指令说明常量相比,用enum关键字说明常量有什么好处? 5.8 如何使部分程序在演示版中失效? 5.9 什么时候应该用宏代替函数? 5.10 使用宏更好,还是使用函数更好? 5.11 在程序中加入注释的最好方法是什么? 5.12 #include和#include“file”有什么不同? 5.13 你能指定在编译时包含哪一个头文件吗? 5.14 包含文件可以嵌套吗? 5.15 包含文件最多可以嵌套几层? 5.16 连接运算符“##”有什么作用? 5.17 怎样建立对类型敏感的宏? 5.18 什么是标准预定义宏? 5.19 怎样才能使程序打印出发生错误的行号? 5.20 怎样才能使程序打印出发生错误的源文件名? 5.2l 怎样判断一个程序是用C编译程序环是用C++编译程序编译的? 5.22 预处理指令#pragma有什么作用? 5.23 #line有什么作用? 5.24 标准预定义宏_FILE_有什么作用? 5.25 怎样在程序中打印源文件名? 5.26 标准预定义宏_LINE_有什么作用? 5.27 怎样在程序中打印源文件的当前行号? 5.28 标准预定义宏_DATE_和_TIME_有什么作用? 5.29 怎样在程序中打印编译日期和时间? 5.30 怎样判断一个程序是否遵循ANSIC标准? 5.31 怎样取消一个已定义的宏? 5.32 怎样检查一个符号是否已被定义? 5.33 C语言提供哪些常用的宏? 第6章 字符串操作 6.l 串拷贝(strcpy)和内存拷贝(memcpy)有什么不同?它们适合于在哪种情况下使用? 6.2 怎样删去字符串尾部的空格? 6.3 怎样删去字符串头部的空格? 6.4 怎样使字符串右对齐? 6.5 怎样将字符串打印成指定长度? 6.6 怎样拷贝字符串的一部分? 6.7 怎样将数字转换为字符串? 6.8 怎样将字符串转换为数字? 6.9 怎样打印字符串的一部分? 6.10 怎样判判断两个字符串是否相同? 第7章 指针和内存分配 7.1 什么是间接引用(indirection)? 7.2 最多可以使用几层指针? 7.3 什么是空指针? 7.4 什么时候使用空指针? 7.5 什么是void指针? 7.6 什么时候使用void指针? 7.7 两个指针可以相减吗?为什么? 7.8 把一个值加到一个指针上意味着什么? 7.9 NULL总是被定义为0吗? 7.10 NULL总是等于0吗? 7.11 用指针作if语句的条件表达式意味着什么? 7.12 两个指针可以相加吗?为什么? 7.13 怎样使用指向函数的指针? 7.14 怎样用指向函数的指针作函数的参数? 7.15 数组的大小可以在程序运行时定义吗? 7.16 用malloc()函数更好还是用calloc()函数更好? 7.17 怎样说明一个大于64KB的数组? 7.18 far和near之间有什么区别? 7.19 什么时候使用far指针? 7.20 什么是栈(stack)? 7.21 什么是堆(heap)? 7.22 两次释放一个指针会导致什么结果? 7.23 NULL和NUL有什么不同? 7.24 为什么不能给空指针赋值?什么是总线错误、内存错误和内存信息转储? 7.25 怎样确定一块已分配的内存的大小? 7.26 free()函数是怎样知道要释放的内存块的大小的? 7.27 可以对void指针进行算术运算吗? 7.28 怎样打印一个地址? 第8章 函数 8.1 什么时候说明函数? 8.2 为什么要说明函数原型? 8.3 一个函数可以有多少个参数? 8.4 什么是内部函数? 8.5 如果一个函数没有返回值,是否需要加入return语句? 8.6 怎样把数组作为参数传递给函数? 8.7 在程序退出main()函数之后,还有可能执行一部分代码吗? 8.8 用PASCAL修饰符说明的函数与普通C函数有什么不同? 8.9 exit()和return有什么不同? . 第9章 数组 9.1 数组的下标总是从0开始吗? 9.2 可以使用数组后面第—个元素的地址吗? 9.3 为什么要小心对待位于数组后面的那些元素的地址呢? 9.4 在把数组作为参数传递给函数时,可以通过sizeof运算符告诉函数数组的大小吗? 9.5 通过指针或带下标的数组名都可以访问数组中的元素,哪一种方式更好呢? 9.6 可以把另外一个地址赋给一个数组名吗? 9.7 array_name和&array;_name有什么不同? 9.8 为什么用const说明的常量不能用来定义一个数组的初始大小? 9.9 字符串和数组有什么不同? 第10章 位(bit)和字节(byte) 10.1 用什么方法存储标志(flag)效率最高? 10.2 什么是“位屏蔽(bit masking)”? 10.3 位域(bit fields)是可移植的吗? 10.4 移位和乘以2这两种方式中哪一种更好? 10.5 什么是高位字节(high-order byte)和低位字节(low-order byte)? 10.6 16位和32位的数是怎样存储的? 第11章 调试 11.1 如果我运行的程序挂起了,应该怎么办? 11.2 如何检测内存漏洞(leak)? 11.3 调试程序的最好方法是什么? 11.4 怎样调试TSR程序? 11.5 怎样获得一个能报告条件失败的程序? 第12章 标准库函数 12.1 为什么应该使用标准库函数而不要自己编写函数? 12.2 为了定义我要使用的标准库函数,我需要使用哪些头文件? 12.3 怎样编写参数数目可变的函数? 12.4 独立(free—standing)环境和宿主(hosted)环境之间有什么区别? 12.5 对字符串进行操作的标准库函数有哪些? 12.6 对内存进行操作的标准库函数有哪些? 12.7 怎样判断一个字符是数字、字母或其它类别的符号? 12.8 什么是“局部环境(locale)”? 12.9 有没有办法从一个或多个函数中跳出? 12.10 什么是信号(signal)?用信号能做什么? 12.11 为什么变量名不能以下划线开始? 12.12 为什么编译程序提供了两个版本的malloc()函数? 12.13 适用于整数和浮点数的数学函数分别有哪些? 12.14 什么是多字节字符(multibyte characters)? 12.15 怎样操作由多字节字符组成的字符串? 第13章 时间和日期 13.1 怎样把日期存储到单个数字中?有这方面的标准吗? 13.2 怎样把时间存储到单个数字中?有这方面的标准吗? 13.3 为什么定义了这么多不同的时间标准? 13.4 存储日期的最好方法是哪一种? 13.5 存储时间的最好方法是哪一种? 第14章 系统调用 14.1 怎样检查环境变量(environment variables)的值? 14.2 怎样在程序中调用DOS函数? 14.3 怎样在程序中调用BIOS函数? 14.4 怎样在程序中存取重要的DOS内存位置? 14.5 什么是BIOS? 14.6 什么是中断? 14.7 使用ANSI函数和使用BIOS函数,哪种方式更好? 14.8 可以通过BIOS把显示模式改为VGA图形模式吗? 14.9 运算符的优先级总能起作用吗(从左至右,从右至左)? 14.10 函数参数的类型必须在函数头部或紧跟在其后说明吗?为什么? 14.11 程序应该总是包含main()的一个原型吗? 14.12 main()应该总是返回一个值吗? 14.13 可以通过BIOS控制鼠标吗? 第15章 可移植性 15.1 编译程序中的C++扩充功能可以用在C程序中吗? 15.2 C++和C有什么区别? 15.3 在C程序中可以用“∥”作注释符吗? 15.4 char,short,int和long类型分别有多长? 15.5 高位优先(big-endian)与低位优先(little—endian)的计算机有什么区别? 第16章 ANSI/ISO标准 16.1 运算符的优先级总能起作用吗? 16.2 函数参数类型必须在函数参数表中或紧跟其后的部分中说明吗? 16.3 程序中必须包含main()的原型吗? 16.4 main()应该总是返回一个值吗? 第17章 用户界面——屏幕和键盘 17.1 为什么直到程序结束时才看到屏幕输出? 17.2 怎样在屏幕上定位光标? 17.3 向屏幕上写数据的最简单的方法是什么? 17.4 向屏幕上写文本的最快的方法是什么? 17.5 怎样防止用户用Ctr+Break键中止程序的运行? 17.6 怎样才能只得到一种特定类型的数据,例如字符型数据? 17.7 为什么有时不应该用scanf()来接收数据? 17.8 怎样在程序中使用功能键和箭头键? 17.9 怎样防止用户向一个内存区域中输入过多的字符? 17.10 怎样用0补齐一个数字? 17.11 怎样才能打印出美元一美分值? 17.12 怎样按科学记数法打印数字? 17.13 什么是ANSI驱动程序? 17.14 怎样通过ANSI驱动程序来清屏? 17.15 怎样通过ANSI驱动程序来存储光标位置? 17.16 怎样通过ANSI驱动程序来恢复光标位置? 17.17 怎样通过ANSI驱动程序来改变屏幕颜色? 17.18 怎样通过ANSI驱动程序来写带有颜色的文本? 17.19 怎样通过ANSI驱动程序来移动光标? 第18章 程序的编写和编译 18.1 程序是应该写成一个源文件还是多个源文件? 18.2 各种存储模式之间有什么区别? 18.3 最常使用的存储模式有哪些? 18.4 应该使用哪种存储模式? 18.5 怎样生成一个".COM"文件? 18.6 ".COM"文件有哪些地方优于".EXE"文件? 18.7 当一个库被连接到目标上时,库中的所有函数是否都会被加到一个".EXE"文件中? 18.8 可以把多个库函数包含在同一个源文件中吗? 18.9 为什么要建立一个库? 18.10 如果一个程序包含多个源文件,怎样使它们都能正常工作? 18.11 连接过程中出现"DGROUP:group exceeds 64K"消息是怎么回事? 18.12 怎样防止程序用尽内存? 18.13 如果程序太大而不能在DOS下运行,怎样才能使它在DOS下运行呢? 18.14 怎样才能使DOS程序获得超过640KB的可用内存呢? 18.15 近程型(near)和远程型(far)的区别是什么? 第19章编程风格和标准 19.1 可以在变量名中使用下划线吗? 19.2 可以用变量名来指示变量的数据类型吗? 19.3 使用注释会影响程序的速度、大小或效率吗? 19.4 使用空白符会影响程序的速度、大小或效率吗? 19.5 什么是骆驼式命名法? 19.6 较长的变量名会影响程序的速度、大小或效率吗? 19.7 给函数命名的正确方法是什么? 19.8 使用大括号的正确方法是什么? 19.9 一个变量名应该使用多少个字母?ANSI。标准允许有多少个有效字符? 19.10 什么是匈牙利式命名法?应该使用它吗? 19.11 什么是重复处理(iterative processing)? 19.12 什么是递归(recursion)?怎样使用递归? 19.13 在C语言中,表示真和假的最好方法是什么? 19.14 空循环(null loops)和无穷循环(infinite loops)有什么区别? 19.15 continue和break有什么区别? 第20章 杂项(Miscellaneous) 20.1 怎样获得命令行参数? 20.2 程序总是可以使用命令行参数吗? 20.3“异常处理(exception handling)”和“结构化异常处理(structured exception handling)”有什么区别? 20.4 怎样在DOS程序中建立一个延时器(delay timer)? 20.5 Kernighan和Ritchie是谁? 20.6 怎样产生随机数? 20.7 什么时候应该使用32位编译程序? 20.8 怎样中断一个Windows程序? 20.9 为什么要使用静态变量? 20.10 怎样在一个程序后面运行另一个程序? 20.11 怎样在一个程序执行期间运行另一个程序? 20.12 怎样把数据从一个程序传给另一个程序? 20.13 怎样判断正在运行的程序所在的目录? 20.14 怎样找到程序中的重要文件(数据库,配置文件,等等)? 20.15 本书的有些例子程序有许多缺陷,为什么不把它们写得更好? 20.16 怎样使用Ctr+Break失效? 20.17 可以使热启动(Ctrl+Alt+Delete)失效吗? 20.18 怎样判断一个字符是否是一个字母? 20.19 怎样判断一个字符是否是一个数字? 20.20 怎样把一个十六进制的值赋给一个变量? 20. 21 怎样把一个八进制的值赋给一个变量? 20.22 什么是二进制? 20.23 什么是八进制? 20.24 什么是十六进制? 20.25 什么是换码符(escape characters)? 附 录 常用函数的包含文件
目 录 第1章 C语言 8 1.1 什么是局部程序块(local block)? 8 1.2 可以把变量保存在局部程序块中吗? 9 1.3 什么时候用一条switch语句比用多条if语句更好? 9 1.4 switch语句必须包含default分支吗? 10 1.5 switch语句的最后一个分支可以不要break语句吗? 11 1.6 除了在for语句中之外,在哪些情况下还要使用逗号运算符? 11 1.7 怎样才能知道循环是否提前结束了? 13 1.8 goto,longjmp()和setjmp()之间有什么区别? 13 1.9 什么是左值(lvaule)? 15 1.10 数组(array)可以是左值吗? 15 1.11 什么是右值(rvaule)? 16 1.12 运算符的优先级总能保证是“自左至右”或“自右至左”的顺序吗? 17 1.13 ++var和var++有什么区别? 17 1.14 取模运算符(modulus operator)“%”的作用是什么? 17 第2章 变量和数据存储 18 2.1. 变量存储在内存(memory)中的什么地方? 18 2.2. 变量必须初始化吗? 19 2.3. 什么是页抖动(pagethrashing)? 19 2.4. 什么是const指针? 20 2.5. 什么时候应该使用register修饰符?它真的有用吗? 21 2.6. 什么时候应该使用volatile修饰符? 21 2.7. 一个变量可以同时被说明为const和volatile吗? 22 2.8. 什么时候应该使用const修饰符? 23 2.9. 浮点数比较(floating-point comparisons)的可靠性如何? 23 2.10. 怎样判断一个数字型变量可以容纳的最大值? 24 2.11. 对不同类型的变量进行算术运算会有问题吗? 25 2.12. 什么是运算符升级(operatorpromotion)? 25 2.13. 什么时候应该使用类型强制转换(typecast)? 26 2.14. 什么时候不应该使用类型强制转换(typecast)? 27 2.15. 可以在头文件中说明或定义变量吗? 27 2.16. 说明一个变量和定义一个变量有什么区别? 27 2.17. 可以在头文件中说明static变量吗? 28 2.18. 用const说明常量有什么好处? 28 第3章 排序与查找 28 排序 28 查找 29 排序或查找性能? 30 3.1. 哪一种排序方法最方便? 32 3.2. 哪一种排序方法最快? 33 3.3. 对外存(磁盘或磁带)中而不是内存中的数据进行排序称为外部排序。 39 3.4. 1哪一种查找方法最方便? 44 3.5. 1哪一种查找方法最快? 46 3.6. 1什么是哈希查找? 51 3.7. 1怎样对链表进行排序? 53 3.8. 1怎样查找链表中的数据? 53 第4章 数据文件 59 4.1. 当errno为一个非零值时,是否有错误发生? 59 4.2. 什么是流(stream)? 59 4.3. 怎样重定向一个标准流? 60 4.4. 怎样恢复一个重定向了的标准流? 60 4.5. stdout能被强制打印到非屏幕设备上吗? 61 4.6. 文本模式(textmode)和二进制模式(binarymode)有什么区别? 61 4.7. 怎样判断是使用流函数还是使用低级函数? 62 4.8. 怎样列出某个目录下的文件? 62 4.9. 怎样列出一个文件的日期和时间? 63 4.10. 怎样对某个目录下的文件名进行排序? 66 4.11. 怎样判断一个文件的属性? 67 4.12. 怎样查看PATH环境变量? 69 4.13. 怎样打开一个同时能被其它程序修改的文件? 69 4.14. 怎样确保只有你的程序能存取一个文件? 71 4.15. 怎样防止其它程序修改你正在修改的那部分文件内容? 71 4.16. 怎样一次打开20个以上的文件? 72 4.17. 怎样避开"Abort,Retry,Fail”消息? 72 4.18. 怎样读写以逗号分界的本? 74 第5章 编译预处理 76 5.1. 什么是宏(macro)?怎样使用宏? 76 5.2. 预处理程序(preprocessor)有什么作用? 77 5.3. 怎样避免多次包含同一个头文件? 79 5.4. 可以用#include指令包含类型名不是".h"的文件吗? 80 5.5. 用#define指令说明常量有什么好处? 80 5.6. 用enum关键字说明常量有什么好处? 81 5.7. 与用#define指令说明常量相比,用enum关键字说明常量有什么好处? 81 5.8. 如何使部分程序在
适用于初学第十章:文件 文件 文件的基本概念   所谓“文件”是指一组相关数据的有序集合。 这个数据集有一个名称,叫做文件名。 实际上在前面的各章中我们已经多次使用了文件,例如源程序文件、目标文件、可执行文件、库文件 (头文件)等。文件通常是驻留在外部介质(如磁盘等)上的, 在使用时才调入内存中来。从不同的角度可对文件作不同的分类。从用户的角度看,文件可分为普通文件和设备文件两种。   普通文件是指驻留在磁盘或其它外部介质上的一个有序数据集,可以是源文件、目标文件、可执行程序; 也可以是一组待输入处理的原始数据,或者是一组输出的结果。对于源文件、目标文件、 可执行程序可以称作程序文件,对输入输出数据可称作数据文件。   设备文件是指与主机相联的各种外部设备,如显示器、打印机、键盘等。在操作系统中,把外部设备也看作是一个文件来进行管理,把它们的输入、输出等同于对磁盘文件的读和写。 通常把显示器定义为标准输出文件, 一般情况下在屏幕上显示有关信息就是向标准输出文件输出。如前面经常使用的printf,putchar 函数就是这类输出。键盘通常被指定标准的输入文件, 从键盘上输入就意味着从标准输入文件上输入数据。scanf,getchar函数就属于这类输入。   从文件编码的方式来看,文件可分为ASCII码文件和二进制码文件两种。   ASCII文件也称为文本文件,这种文件在磁盘中存放时每个字符对应一个字节,用于存放对应的ASCII码。例如,数5678的存储形式为: ASC码:  00110101 00110110 00110111 00111000      ↓     ↓    ↓    ↓ 十进制码: 5     6    7    8 共占用4个字节。ASCII码文件可在屏幕上按字符显示, 例如源程序文件就是ASCII文件,用DOS命令TYPE可显示文件的内容。 由于是按字符显示,因此能读懂文件内容。   二进制文件是按二进制的编码方式来存放文件的。 例如, 数5678的存储形式为: 00010110 00101110只占二个字节。二进制文件虽然也可在屏幕上显示, 但其内容无法读懂。C系统在处理这些文件时,并不区分类型,都看成是字符流,按字节进行处理。 输入输出字符流的开始和结束只由程序控制而不受物理符号(如回车符)的控制。 因此也把这种文件称作“流式文件”。   本章讨论流式文件的打开、关闭、读、写、 定位等各种操作。文件指针在C语言中用一个指针变量指向一个文件, 这个指针称为文件指针。通过文件指针就可对它所指的文件进行各种操作。 定义说明文件指针的一般形式为: FILE* 指针变量标识符; 其中FILE应为大写,它实际上是由系统定义的一个结构, 该结构中含有文件名、文件状态和文件当前位置等信息。 在编写源程序时不必关心FILE结构的细节。例如:FILE *fp; 表示fp是指向FILE结构的指针变量,通过fp 即可找存放某个文件信息的结构变量,然后按结构变量提供的信息找到该文件, 实施对文件的操作。习惯上也笼统地把fp称为指向一个文件的指针。文件的打开与关闭文件在进行读写操作之前要先打开,使用完毕要关闭。 所谓打开文件,实际上是建立文件的各种有关信息, 并使文件指针指向该文件,以便进行其它操作。关闭文件则断开指针与文件之间的联系,也就禁止再对该文件进行操作。   在C语言中,文件操作都是由库函数来完成的。 在本章内将介绍主要的文件操作函数。 文件打开函数fopen   fopen函数用来打开一个文件,其调用的一般形式为: 文件指针名=fopen(文件名,使用文件方式) 其中,“文件指针名”必须是被说明为FILE 类型的指针变量,“文件名”是被打开文件的文件名。 “使用文件方式”是指文件的类型和操作要求。“文件名”是字符串常量或字符串数组。例如: FILE *fp; fp=("file a","r"); 其意义是在当前目录下打开文件file a, 只允许进行“读”操作,并使fp指向该文件。 又如: FILE *fphzk fphzk=("c:\\hzk16',"rb") 其意义是打开C驱动器磁盘的根目录下的文件hzk16, 这是一个二进制文件,只允许按二进制方式进行读操作。两个反斜线“\\ ”中的第一个表示转义字符,第二个表示根目录。使用文件的方式共有12种,下面给出了它们的符号和意义。 文件使用方式        意 义 “rt”      只读打开一个文本文件,只允许读数据 “wt”      只写打开或建立一个文本文件,只允许写数据 “at”      追加打开一个文本文件,并在文件末尾写数据 “rb”      只读打开一个二进制文件,只允许读数据 “wb”       只写打开或建立一个
主体:(一) 一、C++概述 (一) 发展历史 1980年,Bjarne Stroustrup博士开始着手创建一种模拟语言,能够具有面向对象的程序设计特色。在当时,面向对象编程还是一个比较新的理念,Stroustrup博士并不是从头开始设计新语言,而是在C语言的基础上进行创建。这就是C++语言。 1985年,C++开始在外面慢慢流行。经过多年的发展,C++已经有了多个版本。为次,ANSI和ISO的联合委员会于1989年着手为C++制定标准。1994年2月,该委员会出版了第一份非正式草案,1998年正式推出了C++的国际标准。 (二) C和C++ C++是C的超集,也可以说C是C++的子集,因为C先出现。按常理说,C++编译器能够编译任何C程序,但是C和C++还是有一些小差别。 例如C++增加了C不具有的关键字。这些关键字能作为函数和变量的标识符在C程序中使用,尽管C++包含了所有的C,但显然没有任何C++编译器能编译这样的C程序。 C程序员可以省略函数原型,而C++不可以,一个不带参数的C函数原型必须把void写出来。而C++可以使用空参数列表。 C++中new和delete是对内存分配的运算符,取代了C中的malloc和free。 标准C++中的字符串类取代了C标准C函数库头文件中的字符数组处理函数。 C++中用来做控制态输入输出的iostream类库替代了标准C中的stdio函数库。 C++中的try/catch/throw异常处理机制取代了标准C中的setjmp()和longjmp()函数。 二、关键字和变量 C++相对与C增加了一些关键字,如下: typename bool dynamic_cast mutable namespace static_cast using catch explicit new virtual operator false private template volatile const protected this wchar_t const_cast public throw friend true reinterpret_cast try bitor xor_e and_eq compl or_eq not_eq bitand 在C++中还增加了bool型变量和wchar_t型变量: 布尔型变量是有两种逻辑状态的变量,它包含两个值:真和假。如果在表达式中使用了布尔型变量,那么将根据变量值的真假而赋予整型值1或0。要把一个整型变量转换成布尔型变量,如果整型值为0,则其布尔型值为假;反之如果整型值为非0,则其布尔型值为真。布儿型变量在运行时通常用做标志,比如进行逻辑测试以改变程序流程。 #include iostream.h int main() { bool flag; flag=true; if(flag) cout<变量或常数由声明时的类型转换成需要的类型。为此,就要使用强制类型转换说明,格式如下: int* iptr=(int*) &table; 表达式的前缀(int*)就是传统C风格的强制类型转换说明(typecast),又可称为强制转换说明(cast)。强制转换说明告诉编译器把表达式转换成指定的类型。有些情况下强制转换是禁用的,例如不能把一个结构类型转换成其他任何类型。数字类型和数字类型、指针和指针之间可以相互转换。当然,数字类型和指针类型也可以相互转换,但通常认为这样做是不安全而且也是没必要的。强制类型转换可以避免编译器的警告。 long int el=123; short i=(int) el; float m=34.56; int i=(int) m; 上面两个都是C风格的强制类型转换,C++还增加了一种转换方式,比较一下上面和下面这个书写方式的不同: long int el=123; short i=int (el); float m=34.56; int i=int (m); 使用强制类型转换的最大好处就是:禁止编译器对你故意去做的事发出警告。但是,利用强制类型转换说明使得编译器的类型检查机制失效,这不是明智的选择。通常,是不提倡进行强制类型转换的。除非不可避免,如要调用malloc()函数时要用的void型指针转换成指定类型指针。 四、标准输入输出流 在C语言中,输入输出是使用语句scanf()和printf()来实现的,而C++中是使用类来实现的。 #include iostream.h main() //C++中main()函数默认为int型,而C语言中默认为void型。 { int a; cout<>a; /*输入一个数值*/ cout<a; cout<变量的标识符在程序中出现。 五、函数参数问题 (一) 无名的函数形参 声明函数时可以包含一个或多个用不到的形式参数。这种情况多出现在用一个通用的函数指针调用多个函数的场合,其中有些函数不需要函数指针声明中的所有参数。看下面的例子: int fun(int x,int y) { return x*2; } 尽管这样的用法是正确的,但大多数C和C++的编译器都会给出一个警告,说参数y在程序中没有被用到。为了避免这样的警告,C++允许声明一个无名形参,以告诉编译器存在该参数,且调用者需要为其传递一个实际参数,但是函数不会用到这个参数。下面给出使用了无名参数的C++函数代码: int fun(int x,int) //注意不同点 { return x*2; } (二) 函数的默认参数 C++函数的原型中可以声明一个或多个带有默认值的参数。如果调用函数时,省略了相应的实际参数,那么编译器就会把默认值作为实际参数。可以这样来声明具有默认参数的C++函数原型: #include iostream.h void show(int=1,float=2.3,long=6); int main() { show(); show(2); show(4,5.6); show(8,12.34,50L); return 0; } void show(int first,float second,long third) { cout<参数,第二次调用提供了第一个参数,而让编译器提供剩下的两个,第三次调用则提供了前面两个参数,编译器只需提供最后一个,最后一个调用则给出了所有三个参数,没有用到默认参数。 六、函数重载 在C++中,允许有相同的函数名,不过它们的参数类型不能完全相同,这样这些函数就可以相互区别开来。而这在C语言中是不允许的。 1.参数个数不同 #include iostream.h void a(int,int); void a(int); int main() { a(5); a(6,7); return 0; } void a(int i) { cout<参数格式不同 #include iostream.h void a(int,int); void a(int,float); int main() { a(5,6); a(6,7.0); return 0; } void a(int i,int j) { cout<a; for(int i=1;i<=10;i++) //C语言中,不允许在这里定义变量 { static int a=0; //C语言中,同一函数块,不允许有同名变量 a+=i; cout<<::a<< <size; int *array=new int[size]; for(int i=0;i变量 在C++中,引用是一个经常使用的概念。引用型变量是其他变量的一个别名,我们可以认为他们只是名字不相同,其他都是相同的。 1.引用是一个别名 C++中的引用是其他变量的别名。声明一个引用型变量,需要给他一个初始化值,在变量的生存周期内,该值不会改变。& 运算符定义了一个引用型变量: int a; int& b=a; 先声明一个名为a的变量,它还有一个别名b。我们可以认为是一个人,有一个真名,一个外号,以后不管是喊他a还是b,都是叫他这个人。同样,作为变量,以后对这两个标识符操作都会产生相同的效果。 #include iostream.h int main() { int a=123; int& b=a; cout<参数传递给另一个函数时,被调用函数将直接对参数在调用者中的拷贝进行操作,而不是产生一个局部的拷贝(传递变量本身是这样的)。这就称为以引用方式调用。把参数的值传递到被调用函数内部的拷贝中则称为以传值方式调用。 #include iostream.h void display(const Date&,const char*); void swapper(Date&,Date&); struct Date { int month,day,year; }; int main() { static Date now={2,23,90}; static Date then={9,10,60}; display(now,Now: ); display(then,Then: ); swapper(now,then); display(now,Now: ); display(then,Then: ); return 0; } void swapper(Date& dt1,Date& dt2) { Date save; save=dt1; dt1=dt2; dt2=save; } void display(const Date& dt,const char *s) { cout<返回值 #include iostream.h struct Date { int month,day,year; }; Date birthdays[]= { {12,12,60}; {10,25,85}; {5,20,73}; }; const Date& getdate(int n) { return birthdays[n-1]; } int main() { int dt=1; while(dt!=0) { cout<dt; if(dt>0 && dt<4) { const Date& bd=getdate(dt); cout<变量和函数都是类的成员。如果是变量,我们就叫它数据成员如果是函数,我们就叫它成员函数。 3.类成员的可见性 private和public访问控制符决定了成员的可见性。由一个访问控制符设定的可访问状态将一直持续到下一个访问控制符出现,或者类声明的结束。私有成员仅能被同一个类中的成员函数访问,公有成员既可以被同一类中的成员函数访问,也可以被其他已经实例化的类中函数访问。当然,这也有例外的情况,这是以后要讨论的友元函数。 类中默认的数据类型是private,结构中的默认类型是public。一般情况下,变量都作为私有成员出现,函数都作为公有成员出现。 类中还有一种访问控制符protected,叫保护成员,以后再说明。 4.初始化 在声明一个类的对象时,可以用圆括号()包含一个初始化表。 看下面一个例子: #include iostream.h class Box { private: int height,width,depth; //3个私有数据成员 public: Box(int,int,int); ~Box(); int volume(); //成员函数 }; Box::Box(int ht,int wd,int dp) { height=ht; width=wd; depth=dp; } Box::~Box() { //nothing } int Box::volume() { return height*width*depth; } int main() { Box thisbox(3,4,5); //声明一个类对象并初始化 cout<参数,那么声明对象时也不需要括号。 1.使用默认参数的构造函数 当在声明类对象时,如果没有指定参数,则使用默认参数来初始化对象。 #include iostream.h class Box { private: int height,width,depth; public: Box(int ht=2,int wd=3,int dp=4) { height=ht; width=wd; depth=dp; } ~Box(); int volume() { return height*width*depth; } }; int main() { Box thisbox(3,4,5); //初始化 Box defaulbox; //使用默认参数 cout<参数或者参数都是默认值的构造函数称为默认构造函数。如果你不提供构造函数,编译器会自动产生一个公共的默认构造函数,这个构造函数什么都不做。如果至少提供一个构造函数,则编译器就不会产生默认构造函数。 3.重载构造函数 一个类中可以有多个构造函数。这些构造函数必须具有不同的参数表。在一个类中需要接受不同初始化值时,就需要编写多个构造函数,但有时候只需要一个不带初始值的空的Box对象。 #include iostream.h class Box { private: int height,width,depth; public: Box() { //nothing } Box(int ht=2,int wd=3,int dp=4) { height=ht; width=wd; depth=dp; } ~Box(); int volume() { return height*width*depth; } }; int main() { Box thisbox(3,4,5); //初始化 Box otherbox; otherbox=thisbox; cout<参数表的构造函数也把默认值赋值给对象。 class Box { int height,width,depth; public: Box() { height=0;width=0;depth=0; } Box(int ht,int wd,int dp) { height=ht;width=wd;depth=dp; } int volume() { return height*width*depth; } }; 这还不是最好的方法,更好的方法是使用默认参数,根本不需要不带参数的构造函数。 class Box { int height,width,depth; public: Box(int ht=0,int wd=0,int dp=0) { height=ht;width=wd;depth=dp; } int volume() { return height*width*depth; } }; 三、析构函数 当一个类的对象离开作用域时,析构函数将被调用(系统自动调用)。析构函数的名字和类名一样,不过要在前面加上 ~ 。对一个类来说,只能允许一个析构函数,析构函数不能有参数,并且也没有返回值。析构函数的作用是完成一个清理工作,如释放从堆中分配的内存。 我们也可以只给出析构函数的形式,而不给出起具体函数体,其效果是一样的,如上面的例子。但在有些情况下,析构函数又是必需的。如在类中从堆中分配了内存,则必须在析构函数中释放 主体:(三)类的转换 C++的内部数据类型遵循隐式类型转换规则。假设某个表达市中使用了一个短整型变量,而编译器根据上下文认为这儿需要是的长整型,则编译器就会根据类型转换规则自动把它转换成长整型,这种隐式转换出现在赋值、参数传递、返回值、初始化和表达式中。我们也可以为类提供相应的转换规则。 对一个类建立隐式转换规则需要构造一个转换函数,该函数作为类的成员,可以把该类的对象和其他数据类型的对象进行相互转换。声明了转换函数,就告诉了编译器,当根据句法判定需要类型转换时,就调用函数。 有两种转换函数。一种是转换构造函数;另一种是成员转换函数。需要采用哪种转换函数取决于转换的方向。 一、转换构造函数 当一个构造函数仅有一个参数,且该参数是不同于该类的一个数据类型,这样的构造函数就叫转换构造函数。转换构造函数把别的数据类型的对象转换为该类的一个对象。和其他构造函数一样,如果声明类的对象的初始化表同转换构造函数的参数表相匹配,该函数就会被调用。当在需要使用该类的地方使用了别的数据类型,便宜器就会调用转换构造函数进行转换。 #include iostream.h #include time.h #include stdio.h class Date { int mo, da, yr; public: Date(time_t); void display(); }; void Date::display() { char year[5]; if(yr<10) sprintf(year,0%d,yr); else sprintf(year,%d,yr); cout<tm_mon+1; yr=tim->tm_year; if(yr>=100) yr-=100; } int main() { time_t now=time(0); Date dt(now); dt.display(); return 0; } 本程序先调用time()函数来获取当前时间,并把它赋给time_t对象;然后程序通过调用Date类的转换构造函数来创建一个Date对象,该对象由time_t对象转换而来。time_t对象先传递给localtime()函数,然后返回一个指向tm结构(time.h文件中声明)的指针,然后构造函数把结构中的日月年的数值拷贝给Date对象的数据成员,这就完成了从time_t对象到Date对象的转换。 二、成员转换函数 成员转换函数把该类的对象转换为其他数据类型的对象。在成员转换函数的声明中要用到关键字operator。这样声明一个成员转换函数: operator aaa(); 在这个例子中,aaa就是要转换成的数据类型的说明符。这里的类型说明符可以是任何合法的C++类型,包括其他的类。如下来定义成员转换函数; Classname::operator aaa() 类名标识符是声明了该函数的类的类型说明符。上面定义的Date类并不能把该类的对象转换回time_t型变量,但可以把它转换成一个长整型值,计算从2000年1月1日到现在的天数。 #include iostream.h class Date { int mo,da,yr; public: Date(int m,int d,int y) {mo=m; da=d; yr=y;} operator int(); //声明 }; Date::operator int() //定义 { static int dys[]={31,28,31,30,31,30,31,31,30,31,30,31}; int days=yr-2000; days*=365; days+=(yr-2000)/4; for(int i=0;i参数传递 初始化 返回值 表达式语句 这些情况下,都有可能调用转换函数。 下面的程序不难理解,就不分析了。 #include iostream.h class CustomDate { public: int da, yr; CustomDate() {} CustomDate(int d,int y) { da=d; yr=y;} void display() { cout<参数的构造函数用于转换目的,而仅仅希望用它来显式地初始化对象,此时,就需要在构造函数前加explicit。如果在声明了Tester对象以后使用了下面的语句将导致一个错误: ts=jd; //error 这个错误说明,虽然Tester类中有一个以Date型变量参数的构造函数,编译器却不会把它看作是从Date到Tester的转换构造函数,因为它的声明中包含了explicit修饰符。 七、表达式内部的转换 在表达式内部,如果发现某个类型和需要的不一致,就会发生错误。数字类型的转换是很简单,这里就不举例了。下面的程序是把Date对象转换成长整型值。 #include iostream.h class Date { int mo, da, yr; public: Date(int m,int d,int y) { mo=m; da=d; yr=y; } operator long(); }; Date::operator long() { static int dys[]={31,28,31,30,31,30,31,31,30,31,30,31}; long days=yr; days*=365; days+=(yr-1900)/4; //从1900年1月1日开始计算 for(int i=0;ilong ott=123; long sum=ott+today; cout<long) today<< = <返回值和传递给赋值函数的参数不必一一匹配所有数据成员的类型。 #include iostream.h class Date { int mo, da, yr; public: Date(int m,int d,int y) { mo=m; da=d; yr=y; } int getyear() const { return yr; } void setyear(int y) { yr = y; } }; int main() { Date dt(4,1,89); cout<setyear(97); cout<setyear()来提供访问接口,那么使用该类就不必修改他们的代码,仅需要重新编译程序即可。 2.常量成员函数 注意上面的程序中getyear()被声明为常量型,这样可以保证该成员函数不会修改调用他的对象。通过加上const修饰符,可以使访问对象数据的成员函数仅仅完成不会引起数据变动的那些操作。 如果程序声明某个Date对象为常量的话,那么该对象不得调用任何非常量型成员函数,不论这些函数是否真的试图修改对象的数据。只有把那些不会引起数据改变的函数都声明为常量型,才可以让常量对象来调用。 3.改进的成员转换函数 下面的程序改进了从Date对象到CustomDate对象的成员转换函数,用取值和赋值函数取代了使用公有数据成员的做法。(以前的程序代码在上一帖中) #include iostream.h class CustomDate { int da,yr; public: CustomDate() {} CustomDate(int d,int y) { da=d; yr=y; } void display() const {cout<setday(int d) { da=d; } }; class Date { int mo,da,yr; public: Date(int m,int d,int y) { mo=m; da=d; yr=y; } operator CustomDate() const; }; Date::operator CustomDate() const { static int dys[] = {31,28,31,30,31,30,31,31,30,31,30,31}; CustomDate cd(0,yr); int day=da; for(int i=0;isetday(day); return cd; } int main() { Date dt(11,17,89); CustomDate cd; cd=dt; cd.display(); return 0; } 注意上面的程序中Date::operator CustomDate()声明为常量型,因为这个函数没有改变调用它对象的数据,尽管它修改了一个临时CustomDate对象并将其作为函数返回值。 二、友元 前面已经说过了,私有数据成员不能被类外的其他函数读取,但是有时候类会允许一些特殊的函数直接读写其私有数据成员。 关键字friend可以让特定的函数或者别的类的所有成员函数对私有数据成员进行读写。这既可以维护数据的私有性,有可以保证让特定的类或函数能够直接访问私有数据。 1.友元类 一个类可以声明另一个类为其友元,这个友元的所有成员函数都可以读写它的私有数据。 #include iostream.h class Date; class CustomDate { int da,yr; public: CustomDate(int d=0,int y=0) { da=d; yr=y; } void display() const {cout<参数,该参数是它所属的类的一个对象,由于CustomDate类中没有拷贝构造函数,于是编译器就会产生一个默认的拷贝构造函数,该函数简单地把已存在的对象的每个成员拷贝给新对象。现在我们已经知道,编译器可以把Date对象转换成CustomDate对象,也可以从已存在的CustomDate对象生成一个新的CustomDate对象。那么上面提出的问题,编译器就是这样做的:它首先调用转换函数,从Date对象创建一个隐藏的、临时的、匿名的CustomDate对象,然后用该临时对象作为参数调用默认拷贝构造函数,这就生成了一个新的CustomDate对象。 3.预引用 上面的例子中还有这样一句 class Date; 这个语句叫做预引用。它告诉编译器,类Date将在后面定义。编译器必须知道这个信号,因为CustomDate类中引用了Date类,而Date里也引用了CustomDate类,必须首先声明其中之一。 使用了预引用后,就可以声明未定义的类的友元、指针和引用。但是不可以使用那些需要知道预引用的类的定义细节的语句,如声明该类的一个实例或者任何对该类成员的引用。 4.显式友元预引用 也可以不使用预引用,这只要在声明友元的时候加上关键自class就行了。 #include iostream.h class CustomDate { int da,yr; public: CustomDate(int d=0,int y=0) { da=d; yr=y; } void display() const {cout<变量,并且把birthday值赋给它。如果不特别通知编译器,它会简单的认为类的赋值就是成员对成员的拷贝。在上面的程序中,变量birthday有一个字符型指针month,并且在构造函数里用new运算符初始化过了。当birthday离开其作用域时,析构函数会调用delete运算符来释放内存。但同时,当today离开它的作用域时,析构函数同样会对它进行释放操作,而today里的month指针是birthday里的month指针的一个拷贝。析构函数对同一指针进行了两次删除操作,这会带来不可预知的后果。 如果假设today是一个外部变量,而birthday是一个自变量。当birthday离开其作用域时,就已经把对象today里的month指针删除了。显然这也是不正确的。 再假设有两个初始化的Date变量,把其中一个的值赋值给另一个: Date birthday(8,11,1979); Date today(12,29,2003); today=birthday; 问题就更复杂了,当这两个变量离开作用域时,birthday中的month的值已经通过赋值传递给了today。而today中构造函数用new运算符给month的值却因为赋值被覆盖了。这样,birthday中的month被删除了两次,而today中month却没有被删除掉。 二、重载赋值运算符 为了解决上面的问题,我们应该写一个特殊的赋值运算符函数来处理这类问题。当需要为同一个类的两个对象相互赋值时,就可以重载运算符函数。这个方法可以解决类的赋值和指针的释放。 下面的程序中,类中的赋值函数用new运算符从堆中分配了一个不同的指针,该指针获取赋值对象中相应的值,然后拷贝给接受赋值的对象。 在类中重载赋值运算符的格式如下: void operator = (const Date&) 后面我们回加以改进。目前,重载的运算符函数的返回类型为void。它是类总的成员函数,在本程序红,是Date类的成员函数。它的函数名始终是operator =,参数也始终是同一个类的对象的引用。参数表示的是源对象,即赋值数据的提供者。重载函数的运算符作为目标对象的成员函数来使用。 #include iostream.h #include string.h class Date { int mo,da,yr; char *month; public: Date(int m=0, int d=0, int y=0); ~Date(); void operator=(const Date&); void display() const; }; Date::Date(int m, int d, int y) { static char *mos[] = { January,February,March,April,May,June, July,August,September,October,November,December }; mo = m; da = d; yr = y; if (m != 0) { month = new char[strlen(mos[m-1])+1]; strcpy(month, mos[m-1]); } else month = 0; } Date::~Date() { delete [] month; } void Date::display() const { if (month!=0) cout<参数传递给每一个被声明的成员函数,例如: void Date::myFunc(Date* this); 实际编程时函数的声明不需要包含这个参数。 当程序中调用某个对象的成员函数时,编译器会把该对象的地址加入到参数列表中,感觉上就好象函数采用了上面所示的声明,并且是用如下方式来调用的: dt.myFunc(& dt); 静态成员函数不存在this指针。 当调用某个对象的成员函数时,编译器把对象的地址传递给this指针,然后再调用该函数。因此,成员函数你对任何成员的调用实际上都隐式地使用了this指针。 1.以this指针作为返回值 使用this指针可以允许成员函数返回调用对象给调用者。前面的程序中重载赋值运算符没有返回值,因此不能用如下的形式对字符串进行赋值: a=b=c; 为了使重载的类赋值机制也能这样方便,必须让赋值函数返回赋值的结果,在这里就是目标对象。当赋值函数执行时,其返回值也恰好是this指针所指的内容。 下面的程序对前面那个程序进行了修改,让重载赋值运算符返回了一个Date对象的引用。 #include iostream.h #include string.h class Date { int mo,da,yr; char *month; public: Date(int m=0, int d=0, int y=0); ~Date(); void operator=(const Date&); void display() const; }; Date::Date(int m, int d, int y) { static char *mos[] = { January,February,March,April,May,June, July,August,September,October,November,December }; mo = m; da = d; yr = y; if (m != 0) { month = new char[strlen(mos[m-1])+1]; strcpy(month, mos[m-1]); } else month = 0; } Date::~Date() { delete [] month; } void Date::display() const { if (month!=0) cout< name; if (strncmp(name, end, 3) == 0) break; ListEntry* list = new ListEntry(name); if (prev != 0) prev->AddEntry(*list); prev = list; } while (prev != 0) { prev->display(); ListEntry* hold = prev; prev = prev->PrevEntry(); delete hold; } return 0; } 程序运行时,会提示输入一串姓名,当输入完毕后,键入end,然后程序会逆序显示刚才输入的所有姓名。 程序中ListEntry类含有一个字符串和一个指向前一个表项的指针。构造函数从对中获取内存分配给字符串,并把字符串的内容拷贝到内存,然后置链接指针为NULL。析构函数将释放字符串所占用的内存。 成员函数PrevEntry()返回指向链表前一个表项的指针。另一个成员函数显示当前的表项内容。 成员函数AddEntry(),它把this指针拷贝给参数的preventry指针,即把当前表项的地址赋值给下一个表项的链接指针,从而构造了一个链表。它并没有改变调用它的listEntry对象的内容,只是把该对象的地址赋给函数的参数所引用的那个ListEntry对象的preventry指针,尽管该函数不会修改对象的数据,但它并不是常量型。这是因为,它拷贝对象的地址this指针的内容给一个非长常量对象,而编译器回认为这个非常量对象就有可能通过拷贝得到的地址去修改当前对象的数据,因此AddEntry()函数在声明时不需要用const。 主体:(六)类对象数组和静态成员 一、类对象数组 类的对象和C++其他数据类型一样,也可以为其建立数组,数组的表示方法和结构一样。 #include iostream.h class Date { int mo,da,yr; public: Date(int m=0,int d=0, int y=0) { mo=m; da=d; yr=y;} void display() const { cout<参数或者所有参数都有默认值的构造函数叫做默认构造函数。如果类中没有构造函数,编译器会自动提供一个什么都不做的公共默认构造函数 。如果类当中至少有一个构造函数,编译器就不会提供默认构造函数。 如果类当中不含默认构造函数,则无法实例化其对象数组。因为实例花类对象数组的格式不允许用初始化值来匹配某个构造函数的参数表。 上面的程序中,main()函数声明了一个长度为2的Date对象数组,还有一个包含初始化值的单个Date对象。接着把这个初始化的Date对象赋值给数组中第一个对象,然后显示两个数组元素中包含的日期。从输出中可以看到,第一个日期是有效日期,而第二个显示的都是0。 当声明了某个类的对象数组时,编译器会为每个元素都调用默认构造函数。 下面的程序去掉了构造函数的默认参数值,并且增加了一个默认构造函数。 #include class Date { int mo, da, yr; public: Date(); Date(int m,int d,int y) { mo=m; da=d; yr=y;} void display() const { cout <变量,必须在类定义之外来定义该成员。 1.静态数据成员 静态数据成员相当于一个全局变量,类的所有实例都可以使用它。成员函数能访问并且修改这个值。如果这个静态成员是公有的,那么类的作用域之内的所有代码(不论是在类的内部还是外部)都可以访问这个成员。下面的程序通过静态数据成员来记录链表首项和末项的地址。 #include iostream.h #include string.h class ListEntry { public: static ListEntry* firstentry; private: static ListEntry* lastentry; char* listvalue; ListEntry* nextentry; public: ListEntry(char*); ~ListEntry() { delete [] listvalue;} ListEntry* NextEntry() const { return nextentry; }; void display() const { cout<name
前言 引言 本书说明Unix系统的程序设计界面—系统调用界面和标准C提供的很多函数。这些对编写在Unix系统中运行的程序是非常有帮助的。 与大多数操作系统一样,Unix对程序运行提供了大量的服务—打开文件、读文件、启动一道新程序、分配存储区以及获得当前时间等。这些被称之为系统调用界面(system call interface)。另外,标准C库提供了大量C程序广泛使用的函数(格式化输入变量的值、比较两个字符串等)。 系统调用和库函数系统上由Unix程序员手册中的第2,3部分说明。本书不是这些内容的重复。该手册没有给出实例,也不说明这些界面和函数设计的合理性,而这些则正是本书所要弥补的。 Unix标准 在八十年代出现的大量Unix版本的基础上,八十年代后期开始制定了几个国际标准,包括:C程序设计语言的ANSI标准、IEEE POSIX标准族(还在继续制定)、X/open可移植性指南。 本书也说明这些标准,但是并不只是说明这些标准本身,而是着重说明它们与广泛受到重视的一些实现之间的关系,这些实现主要是系统V版本4,以及将发布的4.4BSD。这样也就提供了一种对现实世界的说明,而这正是标准本身及描述符的文献所缺少的。 本书的组织   本书分成6个部分: 1. 对Unix程序设计概念和术语的概要描述(第一章),以及对各种Unix标准化工作和Unix实现的讨论(第二章)。 2. 不带缓存的I/O(第三章)、文件和目录(第四章、标准I/O库(第五章)以及系统数据文件(第六章)。 3. 进程—Unix进程的环境(第七章)、进程控制(第八章)、进程之间的关系(第九章)以及信号(第十章)。 4. 终端I/O(第十一章)、高级I/O(第十二章)以及精灵进程(第十三章) 5. IPC——进程间通信(第十四、十五章)。 6. 实例—一个数据库的函数库(第十六章)、与Postscrip打印机的通信(第十七章)、调制解调器拨号程序(第十八章)以及使用伪终端(第十九章)。 如果对C语言较熟悉并具有某些应用Unix的经验,那么对阅读本书是非常有益的,但是并不要求读者具有Unix的程序设计经验。本书面向的主要读者是:熟悉Unix的程序员,熟悉某个其它操作系统的程序员,他们希望了解大多数Unix系统提供的各种服务的详细情况。 本书中的实例 本书包含大量实例—大约10000行源代码。所有实例都用ANSL C语言编写。在阅读本书时,你应当有一本你所使用的UNIX系统的Unix程序员手册,关于实施的细节等有时需参考该手册。 对于几乎每一个函数和系统调用,本书都用一个小的完整的程序进行演示。这可以让我们清楚地了解它们的用法,包括参数返回值等。有些小程序还不是以说明库函数和系统调用的复杂功能和应用技巧,所以本书中也包含了一些较大的实例(第十六、十七、十八和十九章)。 所有实例的源代码文件都可经Internet用匿名ftp取到,其主机站点是ftjp.uu.net,文件名是published/books/stevens.advprog.tar.Z。在你的机器上可对这些源代码进行修改并运行它们。 用于测试实例的系统 不幸的是所有操作系统都在不断变更,Unix也不例外。下图示出了系统V和4.XBSD的最近进展情况。 4.XBSD是由加州大学贝克莱分校计算机系统研究组开发的。该研究组也发布BSD NET1和BSD NET2版,它们包含了4.XBSD系统公众可用源代码。SVRX是AT& T的系统V的简称。XPG3是X/Open可移植性指南的第三次发行本的简称。ANSI C是C程序设计语言的ANSI标准。POSIX.1是Unix类系统界面的IEEE和ISD标准。2.2和2.3节将对这些标准和版本之间的差别作更多说明。 在本书中,用4.3+BSD表示BSD NET2和4.4BSD之间的Unix系统。 在本书写作时,4.4BSD尚未发行,所以不能称一个系统为4.4BSD。尽管为此, 需要一个简单的名字以引用此种系统,在全书中我们用4.3+BSD。 本书中的大多数实例曾在4种Unix系统上运行过,它们是: 1. U.H公司(UHC)的Unix System V/386 Release4.0 Version 2.0。该系统在Intel 80386处理机上运行。 2. 加州大学贝克莱分校计算机科学系(Computer Science Division)计算机系统研究组的4.3+BSD,该系统在一台HP工作站上运行。 3. 贝克莱软件设计公司的BSD/386(是BSD Net2的导出版),该系统在一台Intel 80386处理机系统上运行。该系统几乎与我们称之为4.3+BSD的相同。 4. Sun Microsystems的Sun OS4.1.1和4.1.2(该系统与贝克莱系统有很深的渊源团系,但也包含了很多系统V的特征),这些系统在SPARC工作站SLC上运行。 本书提供了与测试有关的许多时间信息,也说明了用于测试的系统实际系统。 目录 译者序 前言 第1章 UNIX基础知识 1.1 引言 1.2 登录 1.2.1 登录名 1.2.2 shell 1.3 文件和目录 1.3.1文件系统 1.3.2 文件名 1.3.3路径名 1.3.4工作目录 1.3.5起始目录 1.4输入和输出 1.4.1文件描述符 1.4.2标准输入、标准输出和标准出错 1.4.3不用缓存的I/O 1.4.4标准I/O 1.5程序和进程 1.5.1程序 1.5.2进程和进程ID 1.5.3进程控制 1.6 ANSI C 1.6.1 函数原型 1.6.2类属指针 1.6.3原始系统数据类型 1.7 出错处理 1.8 用户标识 1.8.1 用户ID 1.8.2 组ID 1.8.3 添加组ID 1.9 信号 1.10 UNIX时间值 1.11 系统调用和库函数 1.12 小结 习题 第2章 UNIX标准化及实现 2.1 引言 2.2 UNIX标准化 2.2.1 ANSI C 2.2.2 IEEE POSIX 2.2.3 X/Open XPG3 2.2.4 FIPS 2.3 UNIX实现 2.3.1 SVR4 2.3.2 4.3+BSD 2.4 标准和实现的关系 2.5 限制 2.5.1 ANSI C限制 2.5.2 POSIX限制 2.5.3 XPG3限制 2.5.4 sysconf、pathconf和 fpathconf函数 2.5.5 FIPS 151-1要求 2.5.6 限制总结 2.5.7 未确定的运行时间限制 2.6 功能测试宏 2.7 基本系统数据类型 2.8 标准之间的冲突 2.9 小结 习题 第3章 文件I/O 3.1 引言 3.2 文件描述符 3.3 open函数 3.4 creat函数 3.5 close函数 3.6 lseek函数 3.7 read函数 3.8 write函数 3.9 I/O的效率 3.10 文件共享 3.11 原子操作 3.11.1 添加至一个文件 3.11.2 创建一个文件 3.12 dup和dup2函数 3.13 fcntl函数 3.14 ioctl函数 3.15 /dev/fd 3.16 小结 习题 第4章 文件和目录 4.1 引言 4.2 stat,fstat和lstat函数 4.3 文件类型 4.4 设置-用户-ID和设置-组-ID 4.5 文件存取许可权 4.6 新文件和目录的所有权 4.7 access函数 4.8 umask函数 4.9 chmod 和fchomod函数 4.10 粘住位 4.11 chown, fchown和 lchown函数 4.12 文件长度 4.13 文件截短 4.14 文件系统 4.15 link, unlink, remove和 rename 函数 4.16 符号连接 4.17 symlink 和readlink函数 4.18 文件的时间 4.19 utime函数 4.20 mkdir和 rmdir函数 4.21 读目录 4.22 chdir, fchdir和 getcwd函数 4.23 特殊设备文件 4.24 sync和 fsync函数 4.25 文件存取许可权位小结 4.26 小结 习题 第5章 标准I/O库 5.1 引言 5.2 流和FILE对象 5.3 标准输入、标准输出和标准出错 5.4 缓存 5.5 打开流 5.6 读和写流 5.7 每次一行I/O 5.8 标准I/O的效率 5.9 二进制I/O 5.10 定位流 5.11 格式化I/O 5.12 实现细节 5.13 临时文件 5.14 标准I/O的替代软件 5.15 小结 习题 第6章 系统数据文件和信息 6.1 引言 6.2 口令文件 6.3 阴影口令 6.4 组文件 6.5 添加组ID 6.6 其他数据文件 6.7 登录会计 6.8 系统标识 6.9 时间和日期例程 6.10 小结 习题 第7章 UNIX进程的环境 7.1 引言 7.2 main 函数 7.3 进程终止 7.3.1 exit和_exit函数 7.3.2 atexit函数 7.4 命令行参数 7.5 环境表 7.6 C程序的存储空间布局 7.7 共享库 7.8 存储器分配 7.9 环境变量 7.10 setjmplongjmp函数 7.10.1 自动, 寄存器和易失变量 7.10.2 自动变量的潜在问题 7.11 getrlimit 和setrlimit函数 7.12 小结 习题 第8章 进程控制 8.1 引言 8.2 进程标识 8.3 fork函数 8.4 vfork 函数 8.5 exit函数 8.6 wait和waitpid函数 8.7 wait3和 wait4函数 8.8 竞态条件 8.9 exec函数 8.10 更改用户ID 和组ID 8.10.1 setreuid 和setregid函数 8.10.2 seteuid和 setegid函数 8.10.3 组ID 8.11 解释器文件 8.12 system函数 8.13 进程会计 8.14 用户标识 8.15 进程时间 8.16 小结 习题 第9章 进程关系 9.1 引言 9.2 终端登录 9.2.1 4.3+BSD终端登录 9.2.2 SVR4终端登录 9.3 网络登录 9.3.1 4.3+BSD网络登录 9.3.2 SVR4网络登录 9.4 进程组 9.5 对话期 9.6 终端控制 9.7 tcgetpgrp 和tcsetpgrp函数 9.8 作业控制 9.9 shell执行程序 9.10 孤儿进程组 9.11 4.3+BSD实现 9.12 小结 习题 第10章 信号 10.1 引言 10.2 信号的概念 10.3 signal函数 10.3.1 程序起动 10.3.2 进程创建 10.4 不可靠的信号 10.5 中断的系统调用 10.6 可再入函数 10.7 SIGCLD语义 10.8 可靠信号术语和语义 10.9 kill 和raise函数 10.10 alarm和 pause函数 10.11 信号集 10.12 sigprocmask 函数 10.13 sigpending函数 10.14 sigaction函数 10.15 sigsetjmp 和siglongjmp函数 10.16 sigsuspend函数 10.17 abort函数 10.18 system 函数 10.19 sleep函数 10.20 作业控制信号 10.21 其他特征 10.21.1 信号名字 10.21.2 SVR4信号处理程序的附加参数 10.21.3 4.3+BSD信号处理程序的附加参数 10.22 小结 习题 第11章 终端I/O 11.1 引言 11.2 综述 11.3 特殊输入字符 11.4 获得和设置终端属性 11.5 终端选择标志 11.6 stty命令 11.7 波特率函数 11.8 行控制函数 11.9 终端标识 11.10 规范方式 11.11 非规范方式 11.12 终端的窗口大小 11.13 termcap, terminfo和 curses 11.14 小结 习题 第12章 高级I/O 12.1 引言 12.2 非阻塞I/O 12.3 记录锁 12.3.1 历史 12.3.2 fcntl记录锁 12.3.3 锁的隐含继承和释放 12.3.4 4.3+BSD的实现 12.3.5 建议性锁和强制性锁 12.4 流 12.4.1 流消息 12.4.2 putmsg和 putpmsg函数 12.4.3 流ioct1操作 12.4.4 write至流设备 12.4.5 写方式 12.4.6 getmsg和 getpmsg函数 12.4.7 读方式 12.5 I/O多路转接 12.5.1 select函数 12.5.2 poll函数 12.6 异步I/O 12.6.1 SVR4 12.6.2 4.3+BSD 12.7 readv和writev函数 12.8 readn和 writen函数 12.9 存储映射I/O 12.10 小结 习题 第13章 精灵进程 13.1 引言 13.2 精灵进程的特征 13.3 编程规则 13.4 出错记录 13.4.1 SVR4流log驱动程序 13.4.2 4.3+BSD syslog设施 13.5 客户机-服务器模型 13.6 小结 习题 第14章 进程间通信 14.1 引言 14.2 管道 14.3 popen和 pclose函数 14.4 协同进程 14.5 FIFO 14.6 系统V IPC 14.6.1 标识符和关键字 14.6.2 许可权结构 14.6.3 结构限制 14.6.4 优点和缺点 14.7 消息队列 14.8 信号量 14.9 共享存储 14.10 客户机-服务器属性 14.11 小结 习题 第15章 高级进程间通信 15.1 引言 15.2 流管道 15.3 传送文件描述符 15.3.1 SVR4 15.3.2 4.3BSD 15.3.3 4.3+BSD 15.4 open服务器第1版 15.5 客户机-服务器连接函数 15.5.1 SVR4 15.5.2 4.3+BSD 15.6 open服务器第2版 15.7 小结 习题 第16章 数据库函数库 16.1 引言 16.2 历史 16.3 函数库 16.4 实现概述 16.5 集中式或非集中式 16.6 并发 16.6.1 粗锁 16.6.2 细锁 16.7 源码 16.8 性能 16.8.1 单进程的结果 16.8.2 多进程的结果 16.9 小结 习题 第17章 与PostScript打印机通信 17.1 引言 17.2 PostScript通信机制 17.3 假脱机打印 17.4 源码 17.5 小结 习题 第18章 调制解调器拨号器 18.1 引言 18.2 历史 18.3 程序设计 18.4 数据文件 18.5 服务器设计 18.6 服务器源码 18.7 客户机设计 18.7.1 终端行规程 18.7.2 一个进程还是两个进程 18.8 客户机源码 18.9 小结 习题 第19章 伪终端 19.1 引言 19.2 概述 19.2.1 网络登录服务器 19.2.2 script程序 19.2.3 expect程序 19.2.4 运行协同程序 19.2.5 观看长时间运行程序的输出 19.3 打开伪终端设备 19.3.1 SVR4 19.3.2 4.3+BSD 19.4 pty_fork函数 19.5 pty程序 19.6 使用pty程序 19.6.1 utmp文件 19.6.2 作业控制交互 19.6.3 检查长时间运行程序的输出 19.6.4 script程序 19.6.5 运行协同进程 19.6.6 用交互模式驱动交互式程序 19.7 其他特性 19.7.1 打包模式 19.7.2 远程模式 19.7.3 窗口大小变化 19.7.4 信号发生 19.8 小结 习题 附录A 函数原型 附录B 其他源代码 附录C 习题答案 参考书目

69,371

社区成员

发帖
与我相关
我的任务
社区描述
C语言相关问题讨论
社区管理员
  • C语言
  • 花神庙码农
  • 架构师李肯
加入社区
  • 近7日
  • 近30日
  • 至今
社区公告
暂无公告

试试用AI创作助手写篇文章吧