面向对象程序设计实验报告.docx
《面向对象程序设计实验报告.docx》由会员分享,可在线阅读,更多相关《面向对象程序设计实验报告.docx(33页珍藏版)》请在冰豆网上搜索。
面向对象程序设计实验报告
面向对象程序设计实验报告
实验一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="<}
protected:
inta;
};
classCBase2
{
public:
CBase2(in