实验名称：文件读写操作
　实验目的：掌握文件读写的方法
　
　有一文本文件blog.txt，其中有100行sohu博客地址，如下：
　　　　　 1 waicpp　　　　　 我爱C++
　　　　　 2 admin　　　　　　博客管理员
　　　　　 3 pchxpchx　　　　 维也纳春天
　　　　　 4 greenjiao　　　　快乐的女兵
　　　　　 ......
　
　根据此生成一个文件blog.htm，文件内容如下：
　1、<a href=http://waicpp.blog.sohu.com>我爱C++</a><br>
　2、<a href=http://admin.blog.sohu.com>博客管理员</a><br>
　3、<a href=http://pchxpchx.blog.sohu.com>维也纳春天</a><br>
　4、<a href=http://greenjiao.blog.sohu.com>快乐的女兵</a><br>
　
　

要求：
掌握文本文件读写的方法
了解二进制文件的读写方法

C++文件流：
fstream　　// 文件流
ifstream　 // 输入文件流
ofstream　 // 输出文件流

//创建一个文本文件并写入信息
//同向屏幕上输出信息一样将信息输出至文件
#include<iomanip.h>
#include<fstream.h>
void main()
{
　　ofstream f1("d:\\me.txt");　　　　　　　　　　　//打开文件用于写，若文件不存在就创建它
　　if(!f1)return;　　　　　　　　　　　　　　　　　//打开文件失败则结束运行
　　f1<<setw(20)<<"姓名："<<"廉东方"<<endl;　　　　 //使用插入运算符写文件内容
　　f1<<setw(20)<<"家庭地址："<<"河南郑州"<<endl;
　　f1.close();　　　　　　　　　　　　　　　　　　 //关闭文件
}
运行后打开文件d:\me.txt，其内容如下：
　　　　　　　姓名：廉东方
　　　　　家庭地址：河南郑州

文件操作：
打开文件
　　文件名
　　　　注意路径名中的斜杠要双写，如：
　　　　"D:\\MyFiles\\ReadMe.txt"
　　文件打开方式选项：
　　　　ios::in　　　　= 0x01,　//供读，文件不存在则创建(ifstream默认的打开方式)
　　　　ios::out　　　 = 0x02,　//供写，文件不存在则创建，若文件已存在则清空原内容(ofstream默认的打开方式)
　　　　ios::ate　　　 = 0x04,　//文件打开时，指针在文件最后。可改变指针的位置，常和in、out联合使用
　　　　ios::app　　　 = 0x08,　//供写，文件不存在则创建，若文件已存在则在原文件内容后写入新的内容，指针位置总在最后
　　　　ios::trunc　　 = 0x10,　//在读写前先将文件长度截断为0（默认）
　　　　ios::nocreate　= 0x20,　//文件不存在时产生错误，常和in或app联合使用
　　　　ios::noreplace = 0x40,　//文件存在时产生错误，常和out联合使用
　　　　ios::binary　　= 0x80　 //二进制格式文件
　　文件保护方式选择项：
　　　　filebuf::openprot;　　　//默认的兼容共享方式
　　　　filebuf::sh_none;　　　 //独占，不共享
　　　　filebuf::sh_read;　　　 //读共享
　　　　filebuf::sh_write;　　　//写共享
　　打开文件的方法
　　　　调用构造函数时指定文件名和打开模式
　　　　ifstream f("d:\\12.txt",ios::nocreate);　　　　　　　　 //默认以 ios::in 的方式打开文件，文件不存在时操作失败
　　　　ofstream f("d:\\12.txt");　　　　　　　　　　　　　　　 //默认以 ios::out的方式打开文件
　　　　fstream　f("d:\\12.dat",ios::in|ios::out|ios::binary);　//以读写方式打开二进制文件
　　　　使用Open成员函数
　　　　fstream f;
　　　　f.open("d:\\12.txt",ios::out);　　　　　　　　　　　　　//利用同一对象对多个文件进行操作时要用到open函数
检查是否成功打开
　　成功：
　　　　if(f){...}　　　　　　　//对ifstream、ofstream对象可用，fstream对象不可用。
　　　　if(f.good()){...}
　　失败：
　　　　if(!f){...}　　　　　　 // !运算符已经重载
　　　　if(f.fail()){...}
读写操作
　　使用<<，>>运算符
　　只能进行文本文件的读写操作，用于二进制文件可能会产生错误。
　　使用函数成员 get、put、read、write等
　　经常和read配合使用的函数是gcount()，用来获得实际读取的字节数。
读写二进制文件注意事项
　　打开方式中必须指定ios::binary，否则读写会出错
　　用read\write进行读写操作，而不能使用插入、提取运算符进行操作，否则会出错。
　　使用eof()函数检测文件是否读结束，使用gcount()获得实际读取的字节数
关闭文件
　　使用成员函数close，如：
　　f.close();　
　　利用析构函数
　　对象生命期结束时会检查文件是否关闭，对没有关闭的文件进行关闭操作。
随机读写文件
　　通过移动文件读写指针，可在文件指定位置进行读写。
　　seekg(绝对位置);　　　　　　//绝对移动，　　　　//输入流操作
　　seekg(相对位置,参照位置);　 //相对操作
　　tellg();　　　　　　　　　　//返回当前指针位置
　　seekp(绝对位置);　　　　　　//绝对移动，　　　　//输出流操作
　　seekp(相对位置,参照位置);　 //相对操作　　　
　　tellp();　　　　　　　　　　//返回当前指针位置
　　参照位置：
　　ios::beg　　= 0　　　　　　 //相对于文件头
　　ios::cur　　= 1　　　　　　 //相对于当前位置
　　ios::end　　= 2　　　　　　 //相对于文件尾
读写文本文件的示例
//为能够正确读出写入文件的各数据，各数据间最好要有分隔
#include<fstream.h>
void main()
{
　　fstream f("d:\\try.txt",ios::out);
　　f<<1234<<' '<<3.14<<'A'<<"How are you"; //写入数据
　　f.close();
　　f.open("d:\\try.txt",ios::in);
　　int i;
　　double d;
　　char c;
　　char s[20];
　　f>>i>>d>>c;　　　　　　　　　　　　　　 //读取数据
　　f.getline(s,20);
　　cout<<i<<endl;　　　　　　　　　　　　　//显示各数据
　　cout<<d<<endl;
　　cout<<c<<endl;
　　cout<<s<<endl;
　　f.close();
}
运行结果：
1234
3.14
A
How are you
Press any key to continue
显示文本文件的内容
//使用get()一次读一个字符--------------------------------方案一
#include<fstream.h>
void main()
{
　　ifstream fin("d:\\简介.txt",ios::nocreate);
　　if(!fin){
　　　　cout<<"File open error!\n";
　　　　return;
　　}
　　char c;
　　while((c=fin.get())!=EOF)cout<<c;　　　 //注意结束条件的判断
　　fin.close();
}
//使用get(char *,int n,char delim='\n')一次读多个字符----方案二
//巧妙利用文本文件中不会有字符'\0'的特点进行读取
#include<fstream.h>
void main()
{
　　ifstream fin("d:\\简介.txt",ios::nocreate);
　　if(!fin){
　　　　cout<<"File open error!\n";
　　　　return;
　　}
　　char c[80];
　　while(fin.get(c,80,'\0')!=NULL)cout<<c; //注意结束条件的判断
　　fin.close();
}
//使用read(char *,int n)读文件---------------------------方案三
#include<fstream.h>
void main()
{
　　ifstream fin("d:\\简介.txt",ios::nocreate);
　　if(!fin){
　　　　cout<<"File open error!\n";
　　　　return;
　　}
　　char c[80];
　　while(!fin.eof())　　　　　　　　　　　 //判断文件是否读结束
　　{
　　　　fin.read(c,80);
　　　　cout.write(c,fin.gcount());
　　}
　　fin.close();
}
拷贝文件
//二进制文件操作示例
#include<fstream.h>
void main()
{
　　ifstream fin("C:\\1.exe",ios::nocreate|ios::binary);
　　if(!fin){
　　　　cout<<"File open error!\n";
　　　　return;
　　}
　　ofstream fout("C:\\2.exe",ios::binary);
　　char c[1024];
　　while(!fin.eof())
　　{
　　　　fin.read(c,1024);
　　　　fout.write(c,fin.gcount());
　　}
　　fin.close();
　　fout.close();
　　cout<<"Copy over!\n";
}
　

要求:
理解C++流操作函数
理解I/O流格式控制的两种方法

输出流(cout)基本操作
1、使用流插入运算符（<<）
　　#include<iostream.h>
　　void main()
　　{
　　　　char c[]="Good morning";
　　　　cout<<c<<endl;　　　
　　}
　　运行结果：
　　Good morning
　　Press any key to continue
2、使用成员函数
　　// ostream &put(char);
　　// 输出一个字符，可连续使用
　　#include<iostream.h>
　　void main()
　　{
　　　　cout.put('A').put('\n');
　　}
　　运行结果：
　　A
　　Press any key to continue
　　// ostream &write(const char*,int);
　　// 输出若干个字符
　　#include<iostream.h>
　　void main()
　　{
　　　　char c[]="Good morning";
　　　　cout.write(c,4)<<endl;　　　
　　}
　　运行结果：
　　Good
　　Press any key to continue
输入流(cin)基本操作
1、使用提取运算符（>>）
　　//输入用空格、制表符、回车分隔
　　#include<iostream.h>
　　void main()
　　{
　　　　int i,j; char c;
　　　　cin>>i>>c>>j;
　　　　cout<<i<<"["<<c<<"]"<<j<<endl;
　　}
　　运行结果：
　　123 456
　　123[4]56
　　Press any key to continue
2、使用成员函数
　　// int get();
　　// 读到结束标记返回EOF(-1)
　　#include<iostream.h>
　　void main()
　　{
　　　　while(true)
　　　　{
　　　　　　cout<<cin.get()<<'\\';
　　　　　　if(cin.eof())break;
　　　　}
　　}
　　运行结果：
　　12 34　 5
　　49\50\32\51\52\9\53\10\^Z
　　-1\Press any key to continue
　　// istream &get(char&);
　　// 读到结束标记返回NULL指针
　　#include<iostream.h>
　　void main()
　　{
　　　　char c;
　　　　while(true)
　　　　{
　　　　　　cout<<cin.get(c)<<endl;
　　　　　　if(cin.eof())break;
　　　　}
　　}
　　运行结果：
　　12
　　0x004300EC
　　0x004300EC
　　0x004300EC
　　^Z
　　0x00000000
　　Press any key to continue
　　//istream &get(char*,int n,char delimit='\n');
　　//get不从流中取出结束符，默认结束符是回车
　　#include<iostream.h>
　　void main()
　　{
　　　　char s1[10],s2[10],s3[10];
　　　　cin.get(s1,10);
　　　　cin.get(s2,10);
　　　　cin.get(s3,10);
　　　　cout<<"---------------------\n";
　　　　cout<<s1<<endl;
　　　　cout<<s2<<endl;
　　　　cout<<s3<<endl;
　　}
　　运行结果：
　　1234567890ABCDEF
　　---------------------
　　123456789
　　0ABCDEF
　　
　　Press any key to continue
　　//istream &getline(char*,int n,char delimit='\n');
　　//getline将从流中取出结束符，默认结束符是回车
　　#include<iostream.h>
　　void main()
　　{
　　　　char s1[10],s2[10],s3[10];
　　　　cin.getline(s1,10);
　　　　cin.getline(s2,10);
　　　　cin.getline(s3,10);
　　　　cout<<"---------------------\n";
　　　　cout<<s1<<endl;
　　　　cout<<s2<<endl;
　　　　cout<<s3<<endl;
　　}
　　1234567890ABCDEF
　　Bye bye
　　---------------------
　　123456789
　　0ABCDEF
　　Bye bye
　　Press any key to continue
　　//isrream &read(char *,int);
　　#include<iostream.h>
　　void main()
　　{
　　　　char c[10];
　　　　cin.read(c,10);
　　　　cout.write(c,cin.gcount())<<endl;
　　}
　　运行结果：
　　1234567890ABCDEF
　　1234567890
　　Press any key to continue

2、I/O格式控制
ios类中有一些格式控制标志位，可通过公有函数来改变这些标志位
　　long　　flags() ;　　　　　 //返回标志字的值
　　long　　flags(long);　　　　//设置标志字的值
　　long　　setf(long);　　　　 //设置标志位
　　long　　setf(long,long);　　//设置对齐、数制、浮点标志位
　　long　　unsetf(long);　　　 //清除标志位
　　int　　 width();
　　int　　 width(int);　　　　 //无保持性，对紧随其后输出的数据有效
　　char　　fill();
　　char　　fill(chac);　　　　 //填充字符
　　int　　 precision();
　　int　　 precision(int);　　 //设置精度

设置标志位时，可使用ios类定义的枚举常量：
　　enum {　skipws　　 = 0x0001,
　　　　　　left　　　 = 0x0002,　　// adjustfield
　　　　　　right　　　= 0x0004,
　　　　　　internal　 = 0x0008,
　　　　　　dec　　　　= 0x0010,　　// basefield
　　　　　　oct　　　　= 0x0020,
　　　　　　hex　　　　= 0x0040,
　　　　　　showbase　 = 0x0080,
　　　　　　showpoint　= 0x0100,
　　　　　　uppercase　= 0x0200,
　　　　　　showpos　　= 0x0400,
　　　　　　scientific = 0x0800,　　// floatfield
　　　　　　fixed　　　= 0x1000,
　　　　　　unitbuf　　= 0x2000,
　　　　　　stdio　　　= 0x4000
　　　　 };
　　　　　　　　　　　　　　　　
用成员函数控制：
　　#include<stdio.h>
　　#include<iostream.h>
　　void main()
　　{
　　　　int i=234;
　　　　printf("%08X\n",i);
　　　　cout.setf(ios::hex,ios::basefield);
　　　　cout.setf(ios::uppercase);
　　　　cout.width(8);　
　　　　cout.fill('0');
　　　　cout<<i<<endl;
　　　　cout.setf(ios::dec,ios::basefield);
　　　　cout<<i<<endl;
　　}
　　运行结果：
　　000000EA
　　000000EA
　　234
　　Press any key to continue

用流操纵算子控制格式
　　算子可直接作为I/O输出表达式的一项，算子分为无参算子及有参算子
　　算子分为无参算子　　iostream.h
　　　　dec　　　　　　　　　　 //十进制
　　　　oct　　　　　　　　　　 //八进制
　　　　hex　　　　　　　　　　 //16进制
　　　　endl　　　　　　　　　　//换行
　　　　flush　　　　　　　　　 //立即输出
　　有参算子　　　　　　iomanip.h
　　　　resetiosflags(long)　　 //清除标志位
　　　　setfill(int)　　　　　　//设置填充字符
　　　　setiosflags(long)　　　 //设置标志位
　　　　setprecision(int)　　　 //设置精度
　　　　setw(int)　　　　　　　 //设置宽度
　　//用流操纵算子控制格式
　　#include<iostream.h>
　　#include<iomanip.h>
　　void main()
　　{
　　　　int i=234;
　　　　cout<<hex<<setfill('0')<<setw(8)<<setiosflags(ios::uppercase)<<i<<endl;
　　　　cout<<i<<endl;
　　　　cout<<dec<<i<<endl;
　　　　cout<<setw(8)<<i<<endl;
　　}
　　运行结果：
　　000000EA
　　EA
　　234
　　00000234
　　Press any key to continue
显示浮点数
　　//没指定是定点(fixed)还是科学(scientific)时，默认输出6位有效数字
　　//指定后，精度是指小数点后的有效位数
　　#include<iomanip.h>
　　#include<stdio.h>
　　#include<iostream.h>
　　void main()
　　{
　　　　double d=123.4567890123456789123456789;
　　　　cout<<d<<endl;　　　　　　　　　　　　　//默认6位有效数字
　　　　cout<<setprecision(4)<<d<<endl;　　　　 //保留小数点后3位
　　　　cout<<setiosflags(ios::fixed)<<d<<endl; //科学记数法
　　　　cout<<setprecision(20)<<d<<endl;　　　　//能显示20位吗？
　　　　cout<<resetiosflags(ios::fixed);　　　　//取消定点显示
　　　　cout<<setiosflags(ios::scientific);　　 //科学记数法
　　　　cout<<setprecision(4)<<d<<endl;　　　　 //保留小数点后2位
　　}
　　运行结果：
　　123.457
　　123.5
　　123.4568
　　123.456789012345680
　　1.2346e+002
　　Press any key to continue

实验名称：运算符重载
实验目的：掌握运算符重载的方法

定义分数类，要求如下：
1、能进行分数与分数，分数与整数、整数与分数的加、减、乘、除运算；
2、能用提取运算符>>输入分数，用插入运算符<<输出分数；
类设计好后，用程序加以验证其正确性。

要求：
掌握函数模板的使用

模板是实现代码复用的一种手段，他实现了函数与类的参数化设计方法。
参数化设计是指将函数或类中的某些形参、变量、返回值的类型用“模板参数”替代。
从同一个函数模板实例化的模板函数都是同名的，编译系统通过重载的方法调用相应的函数。

函数模板定义:
　　template <class 模板参数,...>
　　函数类型 函数名(形参表)
　　{
　　　　函数体;
　　}

//函数模板的使用
#include <iostream.h>
#include<string.h>
class fraction
{
　　int n;
　　int d;
public:
　　fraction(int numerator=0,int denominator=1)
　　{
　　　　n=numerator;
　　　　d=denominator;
　　}
　　friend bool operator>(fraction f1,fraction f2)
　　{
　　　　return f1.n*f2.d>f1.d*f2.n;
　　}
　　friend ostream &operator<<(ostream &out,fraction &f)
　　{
　　　　out<<f.n;
　　　　if(f.d!=1)out<<"/"<<f.d;
　　　　return out;
　　}
};
template <class T>
T Max(T a,T b)
{
　　return a>b?a:b;
}
// 下面的函数须直接给出,而不能由模板产生，否则会出现错误
char *Max(char *s1,char *s2)
{
　　return (strcmp(s1,s2)>0)?s1:s2;
}
void main()
{
　　int i1=3,i2=5;
　　cout<<Max(i1,i2)<<endl;
　　char c1='a',c2='b';
　　cout<<Max(c1,c2)<<endl;
　　fraction f1(2,3),f2(3,4);
　　cout<<Max(f1,f2)<<endl;
　　char s1[]="student",s2[]="teacher";
　　cout<<Max(s1,s2)<<endl;
}
运行结果：
5
b
3/4
teacher
Press any key to continue

要求：
掌握运算符的重载的方法

运算符重载函数的一般形式为：
　　返回值类型　operator 重载的运算符(参数列表)
　　{
　　　　//相关操作;
　　}

运算符重载遵循的原则：
　　功能应与运算符的原有功能近似
　　不能改变操作数的个数
　　不能改变运算符的优先级
　　不能改变运算符的结合性
　　不能定义新的运算符
　　至少有一个操作数是自定义类型
　　()、[]、->、=必须重载为类的成员,对于其他的运算符，可重载为成员或友元。
　　.、::、?:、.*、sizeof不可重载

重载为类的成员函数的条件
　　①单目运算符
　　②双目运算符左操作数是类对象
　　双目运算符：operand1　op　operand2
　　相当于： operand1.operator op(operand2)
　　注意：仅传递第2个参数
　　第1个参数是调用该函数的对象
　　可显示使用this指针操作该对象

重载为类的友元函数
　　双目运算符左操作数不是类对象时
　　注意：要传递两个参数给友元函数

　　++,--，可以是前缀操作符，也可以是后缀操作符，为了区分是前缀运算符还是后缀运算符，在重载时将后缀操作符看作二元操作符，增加一个int型参数，但该参数并不参加运算，只是用来区分重载函数。

// 计算：分数*分数
// 结果：分数
#include<iostream.h>
class fraction　　　//分数类
{
　　int n;　　　　　//分子
　　int d;　　　　　//分母
public:
　　fraction(int numerator=0,int denominator=1)
　　{
　　　　n=numerator;
　　　　d=denominator;
　　}
　　fraction operator*(fraction &f2)　　　　　　//分数*分数
　　{
　　　　return fraction(n*f2.n,d*f2.d);
　　}
　　friend void display(char *s,fraction &f)　　//显示分数
　　{
　　　　cout<<s<<f.n<<"/"<<f.d<<endl;
　　}
};
void main()
{
　　fraction a(3,13),b(2),c;
　　c=a*b;
　　display("c=",c);
}
运行结果：
c=6/13
Press any key to continue

// 计算：分数*整数
// 结果：分数
#include<iostream.h>
class fraction　　　//分数类
{
　　int n;　　　　　//分子
　　int d;　　　　　//分母
public:
　　fraction(int numerator=0,int denominator=1)
　　{
　　　　n=numerator;
　　　　d=denominator;
　　}
　　fraction operator*(fraction &f2)　　　　　　//分数*分数
　　{
　　　　return fraction(n*f2.n,d*f2.d);
　　}
　　fraction operator*(int num)　　　　　　　　 //分数*整数
　　{
　　　　return fraction(n*num,d);
　　}
　　friend void display(char *s,fraction &f)　　//显示分数
　　{
　　　　cout<<s<<f.n<<"/"<<f.d<<endl;
　　}
};
void main()
{
　　fraction a(3,13),c;
　　c=a*2;
　　display("c=",c);
}
运行结果：
c=6/8
Press any key to continue

// 计算：整数*分数
// 结果：分数
#include<iostream.h>
class fraction　　　//分数类
{
　　int n;　　　　　//分子
　　int d;　　　　　//分母
public:
　　fraction(int numerator=0,int denominator=1)
　　{
　　　　n=numerator;
　　　　d=denominator;
　　}
　　fraction operator*(fraction &f2)　　　　　　　　//分数*分数
　　{
　　　　return fraction(n*f2.n,d*f2.d);
　　}
　　fraction operator*(int num)　　　　　　　　　　 //分数*整数
　　{
　　　　return fraction(n*num,d);
　　}
　　friend fraction operator*(int num,fraction &f2) //整数*分数
　　{
　　　　return fraction(num*f2.n,f2.d);
　　}
　　friend void display(char *s,fraction &f)　　　　//显示分数
　　{
　　　　cout<<s<<f.n<<"/"<<f.d<<endl;
　　}
};
void main()
{
　　fraction a(3,13),c;
　　c=2*a;
　　display("c=",c);
}
运行结果：
c=6/13
Press any key to continue

//利用构造函数实现类型自动转换
//一个友元函数实现 分数*分数、分数*整数、整数*分数三种操作
#include<iostream.h>
class fraction　　　//分数类
{
　　int n;　　　　　//分子
　　int d;　　　　　//分母
public:
　　fraction(int numerator=0,int denominator=1)
　　{
　　　　n=numerator;
　　　　d=denominator;
　　}
　　friend fraction operator*(fraction f1,fraction f2)
　　{
　　　　return fraction(f1.n*f2.n,f1.d*f2.d);
　　}
　　friend void display(char *s,fraction &f)
　　{
　　　　cout<<s<<f.n<<"/"<<f.d<<endl;
　　}
};
void main()
{
　　fraction a(3,13),b(2),c,d,e;
　　c=a*b;
　　d=a*3;
　　e=4*a;
　　display("c=",c);
　　display("d=",d);
　　display("e=",e);
}
运行结果：
c=6/13
d=9/13
e=12/13
Press any key to continue

// 重载提取运算符>>输入分数
// 重载插入运算符<<输出分数
#include<iostream.h>
class fraction　　　//分数类
{
　　int n;　　　　　//分子
　　int d;　　　　　//分母
public:
　　fraction(int numerator=0,int denominator=1)
　　{
　　　　n=numerator;
　　　　d=denominator;
　　}
　　friend istream &operator>>(istream &in,fraction &f)　　 //提取>>运算符
　　{
　　　　char c;
　　　　f.d=1;
　　　　in>>f.n;
　　　　in.get(c);
　　　　if(c=='/')in>>f.d;
　　　　return in;
　　}
　　friend ostream &operator<<(ostream &out,fraction &f)　　//插入<<运算符
　　{
　　　　out<<f.n;
　　　　if(f.d!=1)out<<"/"<<f.d;
　　　　return out;
　　}
};
void main()
{
　　fraction a,b;
　　cout<<"请输入两个分数：\n";
　　cin>>a>>b;
　　cout<<"a="<<a<<endl;
　　cout<<"b="<<b<<endl;
}
运行结果：
请输入两个分数：
8　3/7
a=8
b=3/7
Press any key to continue

// 复合赋值运算符*=重载
// 利用流对象 cout 输出分数
#include<iostream.h>
class fraction　　　//分数类
{
　　int n;　　　　　//分子
　　int d;　　　　　//分母
public:
　　fraction(int numerator=0,int denominator=1)
　　{
　　　　n=numerator;
　　　　d=denominator;
　　}
　　friend ostream &operator<<(ostream &out,fraction &f)
　　{
　　　　out<<f.n;
　　　　if(f.d!=1)out<<"/"<<f.d;
　　　　return out;
　　}
　　fraction &operator*=(fraction f2)　　　 // 复合赋值运算符*=
　　{
　　　　n*=f2.n;
　　　　d*=f2.d;
　　　　return *this;
　　}
};
void main()
{
　　fraction a(2,13),b(2);
　　b*=a;
　　cout<<b<<endl;
　　cout<<(b*=a)<<endl;
　　cout<<(b*=3)<<endl;
}
运行结果：
4/13
8/169
24/169
Press any key to continue

// 前++、后++
#include<iostream.h>
class fraction　　　//分数类
{
　　int n;　　　　　//分子
　　int d;　　　　　//分母
public:
　　fraction(int numerator=0,int denominator=1)
　　{
　　　　n=numerator;
　　　　d=denominator;
　　}
　　friend ostream &operator<<(ostream &out,fraction &f)
　　{
　　　　out<<f.n;
　　　　if(f.d!=1)out<<"/"<<f.d;
　　　　return out;
　　}
　　fraction &operator++()　　　// 前++
　　{
　　　　n+=d;
　　　　return *this;
　　}
　　fraction operator++(int)　　// 后++
　　{
　　　　fraction f(n,d);
　　　　n+=d;
　　　　return f;
　　}
};
void main()
{
　　fraction a(2,13),b(1,5);
　　cout<<"　a="<<a<<endl;
　　cout<<"++a="<<++a<<endl;
　　cout<<"　a="<<a<<endl;
　　cout<<"　b="<<b<<endl;
　　cout<<"b++="<<b++<<endl;
　　cout<<"　b="<<b<<endl;
}
运行结果：
　a=2/13
++a=15/13
　a=15/13
　b=1/5
b++=1/5
　b=6/5
Press any key to continue

实验名称：基类与派生类
实验目的：掌握派生类的声明、定义、构造与析构

在15周作业person类（可直接拷贝来）的基础上派生出新的类 student。
新类student的成员定义如下，并进行运行测试。

class student:public person
{
private:
　　char xh[20];　　　　　　　　//学号
　　char *jj;　　　　　　　　　 //简介
　　void Set(char *xh,char *jj);//私有成员，设置学号及简介
public:
　　student(char *xh,char *name,int age=18,char *jj=NULL); //构造函数
　　student(student &);　　　　 //拷贝构造函数
　　~student();　　　　　　　　 //析构函数
　　char *GetXh();　　　　　　　//获得学号
　　char *Getjj();　　　　　　　//获得简介
　　void display();　　　　　　 //显示学生信息
};

要求：
理解派生类对象的构造与析构的过程
掌握派生类构造函数的声明和定义方法

派生类构造函数格式：
　　派生类名(形参表):基类名(实参表),...
　　{
　　　　//派生类新增数据成员的初始化;
　　}
　　调用基类构造函数的实参表来自派生类对象构造时的形参表
派生类对象的数据成员包括：
　　1、从基类继承的成员
　　2、派生类新增的成员
派生类对象数据成员初始化的过程：
　　1、调用基类构造函数初始化从基类继承的数据成员，顺序与声明派生类时基类出现的顺序一致
　　2、调用派生类的构造函数初始化新增的数据成员
　　3、派生类的构造函数可以调用基类定义的任何形式的构造函数，执行的是与参数相匹配的构造函数
　　4、析构的顺序与构造函数正好相反
程序示例：
　　// 类继承示例
　　#include <iostream.h>
　　class S 　　// 正方形 square
　　{
　　protected:
　　　　int size;
　　public:
　　　　S() {
　　　　　　size=0;
　　　　　　cout<<"Square无参构造\n";
　　　　}
　　　　S(int s) {
　　　　　　size=s;
　　　　　　cout<<"Square有参构造:"<<s<<endl;
　　　　}
　　　　~S(){ cout<<"Square析构:"<<size<<endl; }
　　　　int Area(){ return size*size; }
　　　　int Size(){ return size; }
　　};
　　class C 　　// 颜色 Color
　　{
　　protected:
　　　　int red,green,blue;
　　public:
　　　　C() {
　　　　　　red=green=blue=0;
　　　　　　cout<<"Color无参构造\n";
　　　　}
　　　　C(int r,int g,int b) {
　　　　　　red=r,green=g,blue=b;
　　　　　　cout<<"Color三参构造:"
　　　　　　　　<<r<<' '<<g<<' '<<b<<endl;
　　　　}
　　　　C(C &c) {
　　　　　　red=c.red,green=c.green,blue=c.blue;
　　　　　　cout<<"Color拷贝构造:"
　　　　　　　　<<red<<' '<<green<<' '<<blue<<endl;
　　　　}
　　　　~C(){ cout<<"Color析构:"<<Color()<<endl; }
　　　　int Color() {
　　　　　　return red+green*256+blue*256*256;
　　　　}
　　};
　　class CC:public S,public C　　//彩色正方体 ColorCube
　　{
　　public:
　　　　CC(){ cout<<"ColoeCube无参构造\n"; }
　　　　CC(int s,C &c):C(c),S(s)
　　　　{
　　　　　　cout<<"ColorCube两参构造:"
　　　　　　　　<<s<<",("
　　　　　　　　<<Color()<<")\n";　 //不能使用 c.red
　　　　}
　　　　CC(int s,int r,int g,int b):S(s),C(r,g,b)
　　　　{
　　　　　　cout<<"ColorCube四参构造:"
　　　　　　　　<<s<<",("<<r<<','<<g<<','<<b<<")\n";
　　　　}
　　　　~CC()
　　　　{
　　　　　　cout<<"ColorCube析构:"<<size
　　　　　　　　<<",("<<Color()<<")\n";
　　　　}
　　　　int Area(){ return 6*S::Area(); }
　　　　int Volume(){ return S::Area()*size; }
　　};
　　void main()
　　{
　　　　S s(15);
　　　　C c(50,100,0);
　　　　CC x, z(10,c);　//CC z(20,50,100,0);
　　　　cout<<"s.Size()="<<s.Size()<<endl;
　　　　cout<<"s.Area()="<<s.Area()<<endl;
　　　　cout<<"c.Color()="<<c.Color()<<endl;
　　　　cout<<"z.Size()="<<z.Size()<<endl;
　　　　cout<<"z.Area()="<<z.Area()<<endl;
　　　　cout<<"z.Color()="<<z.Color()<<endl;
　　　　cout<<"z.Volume()="<<z.Volume()<<endl;
　　}
　　运行结果：
　　Square有参构造:15
　　Color三参构造:50 100 0
　　Square无参构造
　　Color无参构造
　　ColoeCube无参构造
　　Square有参构造:10
　　Color拷贝构造:50 100 0
　　ColorCube两参构造:10,(25650)
　　s.Size()=15
　　s.Area()=225
　　c.Color()=25650
　　z.Size()=10
　　z.Area()=600
　　z.Color()=25650
　　z.Volume()=1000
　　ColorCube析构:10,(25650)
　　Color析构:25650
　　Square析构:10
　　ColorCube析构:0,(0)
　　Color析构:0
　　Square析构:0
　　Color析构:25650
　　Square析构:15
　

要求:
理解单继承、多继承派生类的格式
掌握派生类构造函数的执行过程
理解不同的继承方式对派生类的影响

通过继承，设计人员可从一个已知的类快速建立一个新类，而不必从头开始。新类将继承原有类的属性，还要添加新的特性。派生出来的新类称为派生类，而被继承的类称作基类。从一个基类可以派生出多个派生类，一个派生类也可以由多个基类派生而来。从一个基类派生出一个派生类的过程为单继承，从多个基类派生出一个派生类的过程为多继承。

派生类的定义格式:
class 派生类名:继承方式 基类名,...
{
　　派生类成员
};
关于基类:
　　可有多个基类
　　基类必须已经声明
　　各基类间用逗号分隔
　　每个基类都有自己的继承方式
　　缺省的继承方式是私有的

继承方式有：
　　public
　　protected
　　private(默认)

继承方式对派生类的影响:

派　　基类 　　　　　生 继承方式　　　类	公有	保护	私有
公有派生	公有	保护	不可直接访问
保护派生	保护	保护
私有派生	私有	私有

　
对一个类来说，private和protected成员没有什么区别，它们都仅能被类的成员访问，在类外将不可访问。但作为基类派生新类时就不同了，派生类不能直接访问基类的私有成员，却可直接访问其受保护的成员。

继承的说明：
1、继承基类的所有数据成员和函数成员
2、不继承基类的构造、析构函数和赋值函数
3、派生类中的成员将覆盖基类中同名成员，要使用基类的成员，则要使用作用域运算符
4、若基类间成员重名而派生类未定义该成员则必须使用作用域运算符
5、一个类不能直接从同一类继承一次以上
6、派生类成员有公有\保护\私有\不可直接访问的成员

程序示例:
//派生类继承了基类的成员
#include<iostream.h>
class A
{
public:
　　void f1(){ cout<<"f1() in class A\n";}
};
class B
{
public:
　　void f2(){ cout<<"f2() in class B\n";}
};
class C:public A,public B
{
public:
　　void f3(){ cout<<"f3() in class C\n";}
};
void main()
{
　　C c;
　　c.f1();
　　c.f2();
　　c.f3();
}
运行结果：
f1() in class A
f2() in class B
f3() in class C
Press any key to continue

//派生类中的成员将覆盖基类中同名成员。要使用基类的成员，则要使用作用域运算符
#include<iostream.h>
class A
{
public:
　　void f(){ cout<<"f() in class A\n";}
};
class B:public A
{
public:
　　void f(){ cout<<"f() in class B\n";}
};
void main()
{
　　B b;
　　b.f();
　　b.A::f();
}
运行结果：
f() in class B
f() in class A
Press any key to continue

//若基类间成员重名而派生类未定义该成员则必须使用作用域运算符
#include<iostream.h>
class A
{
public:
　　void f(){ cout<<"f() in class A\n";}
};
class B
{
public:
　　void f(){ cout<<"f() in class B\n";}
};
class C:public A,public B
{ };
void main()
{
　　C c;
　　//c.f();　　//产生二义性
　　c.A::f();　 //作用域运算符
　　c.B::f();
}
运行结果：
f() in class A
f() in class B
Press any key to continue

//基类的私有成员在派生类中将不可直接访问。
//派生类只能通过基类的公有函数访问基类的私有成员
#include<iostream.h>
#include<stdio.h>
class point
{
　　int x,y;
public:
　　void set(int a,int b){ x=a,y=b; }
　　int getx(){ return x; }
　　int gety(){ return y; }
};
class circle:public point
{
　　int r;
public:
　　int getr(){ return r; }
　　void set(int a,int b,int c){ point::set(a,b); r=c; }
　　void display(){ printf("圆心(%d,%d)，半径(%d)\n",getx(),gety(),r); }
};
void main()
{
　　circle c;
　　c.set(2,3,4);
　　c.display();
}
运行结果：
圆心(2,3)，半径(4)
Press any key to continue

//派生类可直接使用基类中受保护的成员
#include<iostream.h>
#include<stdio.h>
class point
{
protected:
　　int x,y;
public:
　　void set(int a,int b){ x=a,y=b; }
　　int getx(){ return x; }
　　int gety(){ return y; }
};
class circle:public point
{
　　int r;
public:
　　int getr(){ return r; }
　　void set(int a,int b,int c){ x=a,y=b,r=c; }
　　void display(){ printf("圆心(%d,%d)，半径(%d)\n",x,y,r); }
};
void main()
{
　　circle c;
　　c.set(2,3,4);
　　c.display();
}
运行结果：
圆心(2,3)，半径(4)
Press any key to continue
　

　

实验名称：拷贝构造、析构、友元函数、静态成员
实验目的：掌握友元的调用方式及静态成员的用途，理解拷贝构造

下面是“人”类的声明，试给出函数的具体定义，并在程序中进行测试。

class person　　　　　　　　　　　　//人类
{
private:
　　static int number;　　　　　　　//静态数据成员，人数
　　void Set(char *n,int a);　　　　//类内调用的函数，
　　char *name;　　　　　　　　　　 //姓名，注意是指针
　　int age;　　　　　　　　　　　　//年龄
public:
　　person(char *n,int a=18);　　　 //构造函数
　　person(person &);　　　　　　　 //拷贝构造函数
　　~person();　　　　　　　　　　　//析构函数
　　static void Number();　　　　　 //显示人的个数
　　friend void Message(person);　　//友元函数（值传递），显示人的信息
};
void person::Set(char *n,int a)　　 //该函数已经写好了，怎么调用它？
{
　　number++;　　　　　　　　　　　 //人数增一
　　name=new char[strlen(n)+1];　　 //动态分配内存
　　strcpy(name,n);　　　　　　　　 //存储姓名
　　age=a;　　　　　　　　　　　　　//存储年龄
}