面向对象方法应用实例资料文件与下载

面向对象方法应用实例

【例1】已有若干学生数据，包括学号，姓名，成绩，要求输出这些学生数据并计算平均分。

类设计分析：设计一个学生类Stud，除了包括number（学号）、name（姓名）和deg（成绩）数据成员外，还有两个静态变量sum和num，分别存放总分和人数。设计一个构造函数用于初始化对象，一个普通成员函数disp()用于显示对象信息和一个静态成员函数avg()用于计算平均分。

完整的程序代码如下：

//p12_11.cpp

#include <iostream>

#include <string>

using namespace std;

class Stud

{

public:

Stud(int n,char na[],int d)   // 构造函数

{

m_number=n;

m_degree=d;

strcpy(m_name,na);

m_sum+=d;

m_numOfStu++;

}

static double Avg()        // 计算平均分

{

return m_sum/m_numOfStu;

}

void Disp()               //显示对象信息

{

cout<<m_number<<"   "<<m_name<<"   "<<m_degree<<endl;

}

private:

int m_number; // 学号

char m_name[10];       // 姓名

int m_degree; // 成绩

static int m_sum;    // 静态成员，总分

static int m_numOfStu; // 静态成员，人数

};

int Stud::m_sum=0;

int Stud::m_numOfStu=0;

int main()

{

Stud s1(1,"Li",89),s2(2, "Chen",78),s3(3, "Zheng",94);

s1.Disp();

s2.Disp();

s3.Disp();

cout<<"average="<<Stud::Avg()<<endl;

return 0;

}

运行结果为：

1 Li 89

2 Chen 78

3 Zheng   94

average=87

【例2】设计一个简单的词典类Dic，每个单词包括英文单词及对应的中文含义，并有一个英汉翻译成员函数，通过查词典的方式将一段英语翻译成对应的汉语。

类设计分析：词典类Dic包括m_top（当前词典指针），m_words（英语单词库），m_mean（对应中文含义库）私有数据成员，以及一个构造函数、Add()（添加单词）和Trans()（英汉翻译）三个公有成员函数。

#include <string>

#include <iostream>

using namespace std;

#define Max 100

class Dic

{

public:

Dic(){m_top=0;}

void Add(char w[],char m[])

{

strcpy(m_words[m_top],w);

strcpy(m_mean[m_top],m);

m_top++;

}

void Trans(char []);

private:

int m_top;

char m_words[Max][12];

char m_mean[Max][20];

};

//翻译函数

void Dic::Trans(char str[])

{

int i=0,j=0,k=0,s;

char w[20],h[200];

while(1)

{

// 提取单词

if(str[i]!=' '&&str[i]!='\0')

w[j++]=str[i];

// 查字典

else

{

w[j]='\0';

for(s=0;s<=m_top;s++)

if(strcmp(m_words[s],w)==0)

break;

if(s<=m_top) // 查到了，将中文释义放入字符串w中

{

strcpy(w,m_mean[s]);

j=strlen(w);

}

else // 没查到，翻译为(unknown)

{

strcpy(w,"(unknown)");  // 没查到，将(unknown)放入字符串w

j=9;

}

// 将单词的中文释义加入到句子的中文释义中

for(s=0;s<j;s++)

h[k++]=w[s];

j=0;

if(str[i+1]=='\0')

{

h[k]='\0';

break;

}

}

i++;

}

// 输出英文原文和中文释义

cout<<"英文:"<<str<<endl;

cout<<"中文:"<<h<<endl;

}

int main()

{

Dic dic1; // 创建一本字典

dic1.Add("a","一个");

dic1.Add("I","我");

dic1.Add("am","是");

dic1.Add("student","学生");

dic1.Trans("I am a student");

dic1.Trans("hello");

return 0;

}

运行结果为：

英文: I am a student

中文:我是一个学生

英文:hello

中文:(unknown)

【例3】设计一个Complex类，进行复数的运算。复数的形式如下：

realpart + imaginaryPart * i

类设计分析：Complex类提供一个带默认参数的构造函数，当不提供初始化值时，构造函数用默认值给对象初始化。类中包含一个公有成员函数Plus()用来做复数的加法、一个静态成员函数Sub()用来做复数的减法。一个普通友元函数Multi()用来做复数的乘法（设计成三种不同的函数类型，是为了让读者了解不同的处理方法在内部实现及函数调用形式上有什么不同）。Display()公有成员函数用来显示复数。两个私有数据成员 m_realPart和m_imgPart用于表示复数的实部和虚部。

#include <iostream>

using namespace std;

class Complex

{

public:

Complex(float r=0,float i=0)

{

m_realPart=r;

m_imgPart=i;

}

void Display();

void Plus(Complex&);

static void Sub(Complex&, Complex&);

friend void Multi(Complex&,Complex&);

private:

float m_realPart;

float m_imgPart;

};

void Complex::Plus(Complex& x)

{

Complex result;

result.m_realPart=m_realPart+x.m_realPart;

result.m_imgPart=m_imgPart+x.m_imgPart;

result.Display();

}

void Complex::Sub(Complex& x, Complex& y)

{

Complex result;

result.m_realPart=x.m_realPart-y.m_realPart;

result.m_imgPart=x.m_imgPart-y.m_imgPart;

result.Display();

}

void Multi(Complex& x,Complex& y)

{

Complex result;

result.m_realPart=x.m_realPart*y.m_realPart-x.m_imgPart*y.m_imgPart;

result.m_imgPart=x.m_realPart*y.m_imgPart+x.m_imgPart*y.m_realPart;

result.Display();

}

void Complex::Display()

{

if(this->m_realPart==0&&this->m_imgPart==0)

cout<<0;

if(this->m_realPart!=0)

cout<<this->m_realPart;

if(this->m_imgPart>0)

cout<<"+"<<this->m_imgPart<<"i"<<endl;

else

if(this->m_imgPart<0)

cout<<this->m_imgPart<<"i"<<endl;

else

cout<<endl;

}

int main()

{

Complex x(5,5),y(2,-2);

x.Plus(y);                     //成员函数调用形式

Complex::Sub(x,y); //静态成员函数调用形式

Multi(x,y);                   //普通友元函数调用形式

return 0;

}

运行结果为：

7+3i

3＋7i

20

【例4】设计一个Bank类，实现银行账号的资金往来账目管理，包括建账号、存入、取出等。

类设计分析：Bank类包括私有数据成员m_top（当前账指针)，m_date（日期），m_money（金额），m_rest（余额）和静态私有数据成员m_sum（累计余额）。另有一个构造函数和三个成员函数Bankin()（处理存入账），Bankout()（处理取出账）和Disp()（输出明细账）。

#include <string>

#include <iostream>

using namespace std;

#define Max 100

class Bank

{

public:     

    Bank()

{

m_top=0;

m_sum=0;

}

    void Bankin(char d[],int m)

    {

strcpy(m_date[m_top],d);

        m_money[m_top]=m;

        m_sum=m_sum+m;

        m_rest[m_top]=m_sum;

        m_top++;

    }

    void Bankout(char d[],int m)

    {

        strcpy(m_date[m_top],d);

        m_money[m_top]=-m;

        m_sum=m_sum-m;

        m_rest[m_top]=m_sum;

        m_top++;

    }

    void Disp();

private:

int m_top;   

    char m_date[Max][15];      // 日期

    int m_money[Max];         // 金额

    int m_rest[Max];           // 剩余金额

    int m_sum;               // 累计余额

};

void Bank::Disp()

{

    int i=0;

    cout<<"  日期   存入  取出 余额"<<endl;

    for(i=0;i<m_top;i++)

    {

cout.width(8);

cout<<right<<m_date[i];

cout<<"  ";

cout.width(11);

if(m_money[i]<0)

cout<<right<<-m_money[i];

else

cout<<left<<m_money[i];

cout.width(6);

cout<<right<<m_rest[i]<<endl;

    }

}

int main()

{

Bank obj;

obj.Bankin("2001.2.5",1000);

obj.Bankin("2001.3.2",2000);

obj.Bankout("2001.4.1",500);

obj.Bankout("2001.4.5",800);

obj.Disp();

return 0;

}

运行结果为：

日期         存入    取出    余额

2001.2.5    1000               1000

2001.3.2    2000               3000

2001.4.1                500     2500

2001.4.5                800     1700

【例 5】编写一个程序，统计学生成绩，其功能包括输入学生的姓名和成绩，按成绩从高到低排列打印输出，将前 80% 的学生定为合格（PASS），而后 20% 的学生定为不合格（FAIL）。

类设计分析：设计一个Student类，包含学生的姓名和成绩等私有数据成员，以及SetName()、SetDeg()、GetName()、和GetDeg()等四个成员函数。设计一个类Compute，包含两个私有数据成员，即学生人数m_numOfStu和Student类的对象组m_stuArray[]，另有三个公共成员函数GetData()、Sort()、Disp()，它们分别用于获取数据、按成绩排序和输出数据。

#include <iostream>

using namespace std;

#define N 10

class Student

{

public:

void SetName(char na[]){strcpy(m_name,na);}

    char *GetName(){return m_name;}

    void SetDeg(int d){m_degree=d;}

    int GetDeg(){return m_degree;}

private:

char m_name[10];

    int m_degree;

};

class Compute

{

public:

void GetData();

    void Sort();

    void Disp();  

private:

int m_numOfStu;

    Student m_stuArray[N];    //对象成员，学生类对象数组

};

void Compute::GetData()

{

    int i,tdeg;

    char tname[10];

cout<<("输入学生人数");

cin>>m_numOfStu;

cout<<"  输入学生姓名和成绩\n";

    for(i=0;i<m_numOfStu;i++)

    {

cin>>tname>>tdeg;

        m_stuArray[i].SetName(tname);

        m_stuArray[i].SetDeg(tdeg);

    }

}

void Compute::Sort()

{

    int i,j,pick;

    Student temp;

    for(i=0;i<m_numOfStu-1;i++)

    {

        pick=i;

        for(j=i+1;j<m_numOfStu;j++)

        {

            if(m_stuArray[j].GetDeg()>m_stuArray[pick].GetDeg())

                pick=j;

        }

        temp=m_stuArray[i];

        m_stuArray[i]=m_stuArray[pick];

        m_stuArray[pick]=temp;

    }

}

void Compute::Disp()

{

    int cutoff,i;

cout<<"输出结果\n";

cout<<"  姓名  成绩  合格否\n";

cout<<"  ----------------------------------\n";

    cutoff=m_numOfStu*8/10-1;

    for(i=0;i<m_numOfStu;i++)

    {

cout.width(6);

cout<<left<<m_stuArray[i].GetName();

cout.width(6);

cout<<right<<m_stuArray[i].GetDeg();

        if(i<=cutoff)

cout<<"\tPASS\n";

        else

cout<<"\tFAIL\n";

    }

}

int main()

{

    Compute list;

    list.GetData();

    list.Sort();

    list.Disp();

return 0;

}

运行结果为：

输入学生人数： 10

输入学生姓名和成绩：

st1  67  st2  80  st3  90  st4  56  st5  88 

st6  75  st7  46  st8  90  st9  66  st10  89

输出结果：

  姓名        成绩        合格否

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

st3           90            PASS

st8           90          PASS

st10          89            PASS

st5           88            PASS

st2           80            PASS

st6           75            PASS

st1           67            PASS

st9           66            PASS

st4           56            FAIL

st7           46            FAIL

【例6】设计一个Date类，用来实现日期的操作。

类设计分析：构造函数带有默认参数，默认时间为1900年1月1日。

sSetDate()函数用来设置日期，并对日期的有效性进行检查。SetYear()、SetMonth()和SetDay()分别设置年、月、日，并对有效性进行检查。GetYear()、GetMonth()、GetDay()用来分别得到年、月、日。

IsLeapYear()函数用来测试某年是否为闰年。一个年份如果能被400整除，或者能被4整除而不能被100整除，则这一年份为闰年，否则为平年。

DaysOfMonth()函数用来得到该月的天数。

NewDate()函数用来计算在日期中增加相应天数或减少相应天数后的新日期。DateComp()函数用来比较两个日期的大小。GetSkip()函数用来计算两个日期相隔的天数。

程序用到较多的函数，所以用多文件结构实现。

//Date.h

class Date  

{

public:

static int DateComp(Date dt1,Date dt2);

static int GetSkip(Date&,Date&);

Date(int =1,int =1,int =1900);

void SetDate(int,int,int);

void SetMonth(int);

void SetDay(int);

void SetYear(int);

void GetDate(int&,int&,int&);

void GetMonth(int&);

void GetDay(int&);

void GetYear(int&);

void PrintDate();

static int IsLeapYear(int);

static int DaysOfMonth(Date&);

static Date NewDate(Date&,int);

private:

// 静态成员二维数组monthDays[][]存储每月的天数

// monthDays[0][]为平年每月天数，monthDays[1][]为闰年每月天数

static const int m_monthDays[2][12];

int m_month;

int m_day;

int m_year;

};

//Date.cpp

#include "Date.h"

#include "iostream"

using namespace std;

// 静态成员变量的初始化

const int Date::m_monthDays[2][12]={{31,28,31,30,31,30,31,31,30,31,30,31},

{31,29,31,30,31,30,31,31,30,31,30,31}};

Date::Date(int m,int d,int y)   // 构造函数

{

m_month=m;

m_day=d;

m_year=y;

}

void Date::SetDate(int m,int d,int y) // 设置日期，按照月、日年顺序

{

if(y<1500||y>2500)   // 判断年份是否在规定范围内

{

cerr<<"Year is wrong";

return;

}

if(m<0||m>12)   // 判断月份是否在规定范围内

{

cerr<<"Month is wrong";

return;

}

if(d<0||d>m_monthDays[Date::IsLeapYear(y)][m-1]) // 判断日是否在规定范围内

{

cerr<<"Day is wrong";

return;

}

m_month=m;

m_day=d;

m_year=y;

}

void Date::SetMonth(int m)   // 设置月份

{

if(m<0||m>12)   // 判断月份是否在规定范围内

{

cerr<<"Month is wrong";

return;

}

m_month=m;

}

void Date::SetDay(int d) // 设置日

{

// 判断日是否在规定范围内

if(d<0||d>m_monthDays[Date::IsLeapYear(m_year)][m_month-1])

{

cerr<<"Day is wrong";

return;

}

m_day=d;

}

void Date::SetYear(int y) // 设置年份

{

if(y<1500||y>2500)   // 判断年份是否在规定范围内

{

cerr<<"Year is wrong";

return;

}

m_year=y;

}

void Date::GetDate(int& m,int& d,int& y) // 读取日期

{

m=m_month;

d=m_day;

y=m_year;

}

void Date::GetMonth(int& m)   // 读取月份

{

m=m_month;

}

void Date::GetDay(int& d)   // 读取日

{

d=m_day;

}

void Date::GetYear(int& y)   // 读取年份

{

y=m_year;

}

void Date::PrintDate()   // 输出日期

{

cout<<m_month<<"-"<<m_day<<"-"<<m_year<<endl;

}

// 判断是否为闰年

int Date::IsLeapYear(int y)  

{

if(y%4==0&&y%100!=0||y%400==0)

return 1;

return 0;

}

// 返回该月的天数

int Date::DaysOfMonth(Date& dt)

{

int days;

// 根据是否为闰年，返回二维数组monthDays[][]中相应的月份天数

days=Date::m_monthDays[Date::IsLeapYear(dt.m_year)][dt.m_month-1];

return days;

}

// 计算日期中增加或减去相应的天数后的新日期

// 增加天数，参数days为正数，减去天数，参数days为负数

Date Date::NewDate(Date& dt,int days)

{

Date tmpDate;

int d=dt.m_day;   // 当前日期的日子

int m=dt.m_month;

int y=dt.m_year;

int md;     // 变量，存储当月的天数

if(days>=0)   // 如果天数大于0，则计算向后的日期，否则计算向前的日期

{

while(1)

{

md=Date::m_monthDays[Date::IsLeapYear(y)][m-1]; //得到当月天数

// 如果当前日期的日子加上天数不超过当月最大天数，则计算完成

if(d+days<=md)

break;

// days减去当月的总天数和当前日子的差，计算出剩余的天数days

days-=md-d;

m++;

if(m==13) // 如果月份超过12

{

y++;   // 年份加1

m=1;   // 月份回到1月

}

d=0;   // 进入到新的月份，日子清0

}

tmpDate.SetDate(m,days,y);

}

else   // 计算向前的日期

{

days=-days;   // 将负天数变为正天数，便于计算

while(1)

{

if(d>days) // 如果当前日期的日子大于剩余天数，则计算完成

break;

days-=d;   // 剩余天数days为当前天数days和当月日子的差

m--;   // 月份减1

if(m==0)    // 如果月份为0

{

y--;   // 年份减1

m=12;   // 月份变为12月

}

// 得到当月的最大天数

md=Date::m_monthDays[Date::IsLeapYear(y)][m-1];

d=md;

}

tmpDate.SetDate(m,d-days,y);

}

return tmpDate;

}

// 计算两个日期间相差的天数

// 如果dt1在dt2之后，返回正数，否则，返回负数

int Date::GetSkip(Date &dt1, Date &dt2)

{

int days1=0,days2=0,years=0,skip=0,i,flag;

Date tmp1,tmp2;

flag=Date::DateComp(dt1,dt2);   // 比较两个日期的大小，将结果存入flag

if(flag==0)   // 如果日期相等，则返回

return 0;

// 变量tmp1中存储较大的日期，tmp2中存储较小的日期

if(flag>0)

tmp1=dt1,tmp2=dt2;  

else

tmp1=dt2,tmp2=dt1;

// 计算日期tmp1从月日开始的总天数

for(i=1;i<tmp1.m_month;i++)

days1+=Date::m_monthDays[Date::IsLeapYear(tmp1.m_year)][i-1];

days1+=tmp1.m_day;

// 计算日期tmp2从月日开始的总天数

for(i=1;i<tmp2.m_month;i++)

days2+=Date::m_monthDays[Date::IsLeapYear(tmp2.m_year)][i-1];

days2+=tmp2.m_day;

//计算两个日期年份相差的总天数

for(i=tmp2.m_year;i<tmp1.m_year;i++)

{

if(Date::IsLeapYear(i))

years+=366;

else

years+=365;

}

// 日期相差天数为年份相差总天数与月份日子相差总天数之和

skip=years+days1-days2;

// 根据日期的大小，判断返回正数或者负数

if(flag>0)

return skip;

else

return -skip;

}

// 比较两个日期的大小

int Date::DateComp(Date dt1, Date dt2)

{

if(dt1.m_year>dt2.m_year)

return 1;

else if(dt1.m_year<dt2.m_year)

return -1;

if(dt1.m_month>dt2.m_month)

return 1;

else if(dt1.m_month<dt2.m_month)

return -1;

if(dt1.m_day>dt2.m_day)

return 1;

else if(dt1.m_day<dt2.m_day)

return -1;

return 0;

}

//mainProgram.cpp

#include "date.h"

#include "iostream"

using namespace std;

int main()

{

int y;

Date dt1(2,18,2003),dt2(10,11,2000);      // 声明两个Date对象并初始化

dt2.GetYear(y);   // 得到dt2的年份并存入变量y

if(Date::IsLeapYear(y))   // 判断y是否为闰年

cout<<"是闰年。"<<endl;

else

cout<<"是平年。"<<endl;

cout<<"日期间隔为：";

cout<<Date::GetSkip(dt1,dt2)<<endl;   // 计算dt1和dt2的日期间隔

dt2.SetDate(3,26,2005);   // 重新设置日期对象dt2

cout<<"日期间隔为：";

cout<<Date::GetSkip(dt1,dt2)<<endl;  // 计算两个日期间隔

cout<<"日期为：";

Date::NewDate(dt2,100).PrintDate();   / 计算从dt2开始，100天后的日期

return 0;

}

运行结果为：

是闰年。

日期间隔为：860

日期间隔为：-767

日期为：7-4-2005