面向对象程序设计实验报告.docx
《面向对象程序设计实验报告.docx》由会员分享，可在线阅读，更多相关《面向对象程序设计实验报告.docx（39页珍藏版）》请在冰点文库上搜索。
面向对象程序设计实验报告
面向对象程序设计实验报告
面向对象程序设计实验报告
学生所在学院：
信息科学与工程学院
学生所在班级：
学生姓名：
指导教师：
实验一C++基础
1.1实验目的
1.了解并熟悉开发环境，学会调试程序；
2.熟悉C++中简单的标准输入输出函数的使用方法；
3.理解const修饰符的作用并学会应用；
4.理解内联函数的优缺点并学会其使用场合；
5.理解并学会函数重载；
6.理解并熟练掌握使用new和delete来分配内存；
7.理解并熟练掌握引用的使用方法。
1.2实验内容
1.2.1程序阅读
1.理解下面的程序并运行，然后回答问题。
#include
intmax_def（intx,inty）
{
return（x>y?
x:
y）;
}
intmax_def（intx,inty,intz）
{
inttemp=0;
return（temp=（x>y?
x:
y））>z?
temp:
z;
}
doublemax_def（doublex,doubley）
{
return（x>y?
x:
y）;
}
intmain（）
{
intx1=0;
intx2=0;
doubled1=0.0;
doubled2=0.0;
x1=max_def（5,6）;
x2=max_def（2,3,4）;
d1=max_def（2.1,5.6）;
d2=max_def（12.3,3.4,7.8）;-------------------------------------------------------①
cout<<"x1="<cout<<"x2="<cout<<"d1="<cout<<"d2="<return1;
}
问题一：
上述程序的输出结果是什么？
答：
输出结果为
问题二：
①处调用的是哪个函数？
答：
①处调用的是doublemax_def（doublex,doubley）函数
问题三：
②处的输出结果为什么是d2=12，而不是d2=12.3？
答：
因为调用的intmax_def（intx,inty,intz）函数返回值为整型。
2.理解下面的程序并运行，然后回答问题。
#include
intmain（）
{
int*p1=newint;------------------------------------------------------①
int*p2=newint（0）;-------------------------------------------------------②
char*p3=newchar[10];----------------------------------------------------③
return1;
}
问题一：
①、②、③处动态申请内存分别代表什么意思？
答：
①处：
定义一个整型指针动态分配一个整型空间将首地址赋给p1；
②处：
定义一个整型指针动态分配一个整型空间，并赋值为0；
③处：
定义一个字符型指针动态分配具有10个数组元素的字符数组空间，将首地址赋给p3。
问题二：
该程序存在什么不合理的地方？
答：
程序结束时没有释放分配的存储空间。
3.理解下面的程序并运行，然后回答问题。
#include
voidswap（inta,intb）
{
inttemp=a;
a=b;
b=temp;
}
voidswap（int*a,int*b）
{
inttemp=*a;
*a=*b;
*b=temp;
}
intmain（）
{
inti=5;
intj=10;
cout<<"Beforeswap:
i="<swap（i,j）;
cout<<"Afterthefirstswap:
i="<swap（&i,&j）;
cout<<"Afterthesecondswap:
i="<return1;
}
问题一：
输出结果是什么？
答：
问题二：
①处函数调用不能实现两个数的交换，而②可以，原因是什么？
答：
①处调用的函数形参为整型变量，是值传递，形参的改变不影响实参；
②处调用的函数形参为指针，是址传递，形参的改变会导致实参的改变。
问题三：
②处调用的是哪个函数？
答：
调用的函数是voidswap（int*a,int*b）。
实验二类和对象——类的构建
2.1实验目的
1.类的定义；
2.类对象的使用；
3.类成员变量的定义和使用；
4.类成员函数的定义和使用；
5.理解类的作用域；
6.理解类的声明；
7.理解类中成员的访问属性；
2.2实验内容
2.2.1程序阅读
1.理解下面的程序并运行，然后回答后面的问题。
#include
classCDate
{
public:
voidSet（intm,intd,inty）
{
month=m;
day=d;
year=y;
}
intIsLeapYear（）
{
return（year%4==0&&year%100!
=0）||（year%400==0）;
}
voidPrint（）
{
cout<}
private:
intmonth;
intday;
intyear;
};
voidmain（）
{
CDatea;
a.Set（10,15,2007）;
a.Print（）;
}
问题一：
以上程序为什么不能通过编译？
如何改正？
答：
因为Set函数被设为私有main函数中无法调用，应在set函数前加public。
问题二：
类中的成员函数和成员变量分别属于哪种访问权限？
答：
数据成员为私有，Print为公有；set原为私有，改正后为公有。
问题三：
①处语句的意思是什么？
答：
将类定义一个对象a。
2.理解下面的程序并运行，然后回答问题。
.#include
intmonth;//全局变量
intday;
intyear;
voidSet（intm,intd,inty）
{
:
:
month=m;
:
:
day=d;
:
:
year=y;
}
classCDate
{
public:
voidSet（intm,intd,inty）
{
:
:
Set（m,d,y）;
}
voidPrint（）
{
cout<}
private:
intmonth;
intday;
intyear;
};
voidmain（）
{
CDatea;
a.Set（10,15,2007）;
a.Print（）;
}
问题一:
①处是在给成员变量赋值还是全局变量赋值，如果去掉域作用符：
：
，程序是否还能正确运行？
答：
全局变量，不能。
问题二：
②处调用的哪个函数，如果去掉域作用符：
：
，程序是否还能正确运行？
答：
调用全局set函数；不能。
问题三：
程序的输出结果是？
答：
实验三类和对象——构造函数与析构函数
3.1实验目的
1.理解this指针的作用和用法；
2.掌握构造函数的定义和作用；
3.掌握构造函数的使用；
4.掌握拷贝构造函数的定义和使用；
5.掌握构造函数的重载；
6.掌握析构函数的定义和使用。
3.2实验内容
3.2.1程序阅读
1.理解下面的程序并运行，然后回答问题。
#include
classCPoint
{
public:
voidSet（intx,inty）;
voidPrint（）;
private:
intx;
inty;
};
voidCPoint:
:
Set（intx,inty）
{
x=x;
y=y;
}
voidCPoint:
:
Print（）
{
cout<<"x="<}
voidmain（）
{
CPointpt;
pt.Set（10,20）;
pt.Print（）;
}
问题一：
以上程序编译能通过吗？
如果不能，原因是什么？
答：
能通过编译。
问题二：
以上程序的运行结构是否正确，如果不正确，分析为什么，如何改正？
答：
运行结构不正确，因为Set函数中，x=x，参数x覆盖数据成员，使得数据成员并没有被赋值。
2.理解下面的程序并运行，然后回答后面的问题。
include
classCPerson
{
public:
voidPrint（）;
private:
CPerson（）;
private:
intage;
char*name;
};
CPerson:
:
CPerson（）
{
}
voidCPerson:
:
Print（）
{
cout<<"name="<}
voidmain（）
{
CPersonps（23,"张三"）;
ps.Print（）;
}
问题一：
以上程序存在三个错误，在不改变主函数内容的前提下，试改正该程序。
答：
第一处错误是：
在程序头应添加#include文件，第二处错误是：
构造函数没有参数，应添加为（inti,charj），第三处错误是：
构造函数没有函数体。
改正后的程序为：
#include
#include
classCPerson
{
public:
voidPrint（）;
CPerson（inti,char*j）;
public:
intage;
char*name;
};
CPerson:
:
CPerson（inti,char*j）
{
age=i;
name=j;
}
voidCPerson:
:
Print（）
{
cout<<"name="<}
voidmain（）
{
CPersonps（23,"张三"）;
ps.Print（）;
}
实验四类和对象—对象传递与静态成员
4.1实验目的
1.静态成员（静态数据成员、静态成员函数）的作用与使用时的注意事项
2.掌友元（友元函数、友元类）的作用和使用；
3.理解常类型。
4.2实验内容
4.2.1程序阅读
1.理解下面的程序并运行，然后回答后面的问题。
#include
#include
classCStudent
{
public:
CStudent（char*n,inta）;
~CStudent（）;
staticvoidSetAge（intage）;
private:
char*name;
intage;
staticintnTotalObj;
};
intCStudent:
:
nTotalObj=0;
CStudent:
:
CStudent（char*n,inta）
:
age（a）
{
intnLcn=strlen（n）;
name=newchar[nLen+1];
strcpy（name,n）;
name[nLen]='\0';
nTotalObj++;
}
CStudent:
:
~CStudent（）
{
delete[]name;
nTotalObj--;
}
voidCStudent:
:
SetAge（intage）
{
this->age=age;
}
voidmain（）
{
CStudentstu1（"张三",25）;
CStudentstr2（"李四",26）;
cout<<"CStudent:
:
nTotalObj="<:
nTotalObj<}
问题一：
以上程序编译能通过吗，为什么？
答：
不能，CStudent:
:
nTotalObj为私有变量，类引不能访问。
问题二：
成员变量nTotalObj起什么作用，它是如何实现的？
答：
统计该类所创建对象的个数，通过声明为静态。
问题三：
如果不改编主函数和类Cstudent中的成员变量的属性，应该如何改正该程序？
答：
可以将staticintnTotalObj声明为公有。
2.理解下面的程序并运行，然后回答后面的问题。
#include
#include
classCStudent
{
public:
CStudent（char*n,inta）;
~CStudent（）;
private:
char*name;
intage;
};
CStudent:
:
CStudent（char*n,inta）
:
age（a）
{
intnLen=strlen（n）;
name=newchar[nLen+1];
strcpy（name,n）;
name[nLen]='\0';
}
CStudent:
:
~CStudent（）
{
delete[]name;
}
classCTeacher
{
public:
CTeacher（char*tn,intta）;
~CTeacher（）;
voidSetStuAge（inta）;
private:
char*name;
intage;
CStudentstu;
};
CTeacher:
:
CTeacher（char*tn,intta）
:
age（ta）
{
intnLen=strlen（tn）;
name=newchar[nLen+1];
strcpy（name,tn）;
name[nLen]='\0';
}
CTeacher:
:
~CTeacher（）
{
delete[]name;
}
voidCTeacher:
:
SetStuAge（inta）
{
stu.age=a;
}
voidmain（）
{
CStudentstu1（"张三",25）;
CStudentstr2（"李四",26）;
}
问题一：
以上程序有两个错误，指出并改正。
答：
第一处错误是Cstudentage为私有，Cteacher无法访问。
第二处错误是Cteacher中Cstudent未初始化。
改正：
①public:
intage②Cteacher:
:
Cteacher（char*tn,intta）:
:
age（ta）,stu（tn,ta）
3.理解下面的程序并运行，然后回答后面的问题。
#include
classDate
{
private:
constintyear;
constintmonth;
constintday;
public:
Date（inty,intm,intd）;
voidshowdate（）;
};
Date:
:
Date（inty,intm,intd）
{
year=y;
month=m;
day=d;
}
voidDate:
:
showdate（）
{
cout<}
voidmain（）
{
constDateobj（2007,10,30）;
obj.showdate（）;
}
问题一：
以上程序有两个错误，试指出来，并改正之？
答：
第一处错误是：
构造函数应该用成员初始化列表对常数据成员初始化；第二处错误是：
没有用常成员函数访问常对象数据成员。
改正后的程序为：
#include
usingnamespacestd;
classDate
{
private:
constintyear;
constintmonth;
constintday;
public:
Date（inty,intm,intd）;
voidshowdate（）const;
};
Date:
:
Date（inty,intm,intd）:
year（y）,month（m）,day（d）
{
}
voidDate:
:
showdate（）const
{
cout<}
voidmain（）
{
Dateobj（2007,10,30）;
obj.showdate（）;
}
实验五派生与继承—单基派生
5.1实验目的
1.理解继承的概念；
2．理解共有派生、私有派生和保护派生；
3.理解单基派生类中构造函数和析构函数的执行顺序。
5.2实验内容
5.2.1程序阅读
1.理解下面的程序并运行，然后回答后面的问题。
#include
classCBase
{
public:
CBase（inta）
:
a（a）
{
}
protected:
voidprint（）
{
cout<<"a="<}
private:
inta;
};
classCDerive:
publicCBase
{
public:
voidprint（）
{
CBase:
:
print（）;
cout<<"b="<}
private:
intb;
}
voidmain（）
{
CDerived;
d.print（）;
CBaseb;
b.print（）;
}
问题一：
以上程序有两个错误，试指出来，并改正之。
答：
类CBase中的成员数据应该为公有访问属性，第二个错误是构造函数有问题。
改正后的程序有两种：
①
#include
usingnamespacestd;
classCBase
{
public:
CBase（inta）:
a（a）
{
}
Voidprint（）
{
cout<<"a="<}
public:
inta;
};
classCDerive:
publicCBase
{
public:
CDerive（inta,intb）:
CBase（a）,b（b）
{
}
voidprint（）
{
CBase:
:
print（）;
cout<<"b="<}
private:
intb;
};
voidmain（）
{
CDerived（6,4）;
d.print（）;
CBaseb（5）;
b.print（）;
}
②
#include
usingnamespacestd;
classCBase
{
public:
voidprint（）
{
cout<<"a="<}
public:
inta;
};
classCDerive:
publicCBase
{
public:
voidprint（）
{
CBase:
:
print（）;
cout<<"b="<}
private:
intb;
};
voidmain（）
{
CDerived;
d.print（）;
CBaseb;
b.print（）;
}
2.理解下面的程序并运行，然后回答后面的问题。
#include"iostream.h"
classCBase
{
public:
CBase（inta）
:
a（a）
{
cout<<"basestructure"<}
~CBase（）
{
cout<<"basedestructure"<}
voidprint（）
{
cout<<"a="<}
protected:
inta;
};
classCDerive:
publicCBase
{
public:
CDerive（inta,intb,intc）
:
CBase（a）,b（b）,c（c）
{
cout<<"dervicestructure"<}
~CDerive（）
{
cout<<"derivedestructure"<}
voidprint（）
{
CBase:
:
print（）;
cout<<"b.a="<cout<<"c="<}
private:
CBaseb;
intc;
};
voidmain（）
{
CDerived（1,2,3）;
d.print（）;
}
问题一：
以上程序的输出结果是什么，为什么？
答：
输出结果是
原因是基类和派生类中构造函数和析构函数的执行顺序。
问题二：
①处语句执行完后，d.b.a的值为多少？
答：
值为1。
实验六派生与继承—多基派生
6.1实验目的
1.理解多基派生的定义；
2.基派生中的构造函数与析构函数的调用顺序；
3.理解多基派生中虚基类的作用。
6.2实验内容
6.2.1程序阅读
1.理解下面的程序并运行，然后回答后面的问题。
classCBase1
{
public:
CBase1（inta）
:
a（a）
{
cout<<"base1structure..."<}
~CBase1（）
{
cout<<"base1destructure..."<}
voidprint（）
{
cout<<"a="<
升级会员 