当前位置：文档库 › 面向对象程序设计实验

面向对象程序设计实验

实验一 C++基础1.1 实验目的

1．了解并熟悉开发环境，学会调试程序；

2．熟悉C++中简单的标准输入输出函数的使用方法；

3．理解const修饰符的作用并学会应用；

4．理解内联函数的优缺点并学会其使用场合；

5．理解并学会函数重载；

6．理解并熟练掌握使用new和delete来分配内存；

7．理解并熟练掌握引用的使用方法。

1.2 实验内容

1.2.1 程序阅读

1．理解下面的程序并运行，然后回答问题。

#include

int max_def(int x, int y)

{

return (x>y?x:y);

}

int max_def(int x, int y, int z)

{

int temp = 0;

return (temp=(x>y?x:y))>z?temp:z;

}

double max_def(double x, double y)

{

return (x>y?x:y);

}

int main()

int x1 = 0;

int x2 = 0;

double d1 = 0.0;

double d2 = 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="<

return 1;

}

问题一：上述程序的输出结果是什么？

问题二：用的是哪个函数？

答：调用的函数是

int max_def(int x, int y, int z)

{

int temp = 0;

return (temp=(x>y?x:y))>z?temp:z;

}

问题三：②处的输出结果为什么是d2=12，而不是d2=12.3？

答：因为①处调用的是整型函数，d2在此函数中被转换为整型，小数点后面被删除。

2．理解下面的程序并运行，然后回答问题。

#include

int main()

{

int *p1 = new int;

-----------------------------------------------------①

int *p2 = new int(0);

-----------------------------------------------------②

char *p3 = new char[10];

-----------------------------------------------------③

return 1;

}

问题一：①、②、③处动态申请内存分别代表什么意思？

答：①new动态分配存放一个整数的内存空间，并将其首地址赋给指针变量p1；②new动态分配存放一个整数的内存空间，并对其初始化赋值为0，并将其首地址赋给指针变量p2；③new 动态分配存放10个字符型数组元素的内存空间，并将其首地址赋给指针变量p3。

问题二：该程序存在什么不合理的地方？。

答：程序结束时没有将分配的空间释放，应该使用delete函数释放内存。

3．理解下面的程序并运行，然后回答问题。

#include

void swap(int a, int b)

{

int temp = a;

a = b;

b = temp;

}

void swap(int *a, int *b)

{

int temp = *a;

*a = *b;

*b = temp;

}

int main()

{

int i = 5;

int j = 10;

cout<<"Before swap: i="<

swap(i,j); -----------------------------------------------------①cout<<"After the first swap: i="<

swap(&i,&j); -----------------------------------------------------②

cout<<"After the second swap: i="<

return 1;

}

问题一：输出结果是什么？

问题二：①处函数调用不能实现两个数的交换，而②可以，原因是什么？

答：①处调用的函数只是交换了局部变量a和b，并没有改变i和j的值；②处调用的函数使用了引用形参，i和j的值随着此处调用的函数中a和b的对换而对换。

问题三：②处调用的是哪个函数？

答：调用的函数是

void swap(int a, int b)

{

int temp = a;

a = b;

b = temp;

}

1.2.2 程序设计

1．定义两个重名函数，分别求出两点间平面距离和空间距离。

#include

using namespace std;

int distance(int x1,int y1 ,int x2,int y2)

{

double dis;

dis=sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2));

cout<

return dis;

}

int distance(int x1,int y1,int x2,int y2,int z1,int z2)

{

double dis;

dis=sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2)+(z1-z2)*(z1-z2));

cout<

return dis;

}

void main()

{

int a;

int i,j,k,l,q,w,e,r,t,y;

cout<<"请输入平面两点坐标："<

cin>>i>>j>>k>>l;

a=distance(i,j,k,l);

cout<<"请输入空间两点坐标"<

cin>>q>>w>>e>>r>>t>>y;

a=distance(q,w,e,r,t,y);

}

2．设计一个函数：exch()，当调用exch (a,b,c)时，将a赋值给b，b赋值给c，c赋值给a，要求采用引用的方式来实现。

#include

using namespace std;

void exch(int &m,int &n,int &p)

{

int temp=p;

p=n;

n=m;

m=temp;

}

int main()

int a=1,b=2,c=3;

cout<<"a="<

exch(a,b,c);

cout<<"a="<

return 0;

}

1.3 思考题

1．自己设计一个程序，测试指向常量的指针，常指针，指向常量的常指针之间的区别。

#include

using namespace std;

void main()

{

int a = 10;

int const *p = &a;

cout<

cout<<*p<

int b = 20;

}

我们可以改变指针变量p所指向的内容，而不能改变p的地址空间，如添加上p = &b;我们就会发现编译错误！指向常量的指针const ——int*p，特点是指针所保存的地址可以改变，然而指针所指向的值却不可以改变。同理，当添加*p = b时，会发生编译错误！指向常量的常指针

const int const*p特点是指针所保存的地址不可变，指针所指向的数值也不可变。

2．编写一个函数，实现两个字符串变量的交换。

#include

using namespace std;

void Exchg2(char *m,char *n)

{

char tmp = *m;

*m = *n;

*n = tmp;

}

void main()

char a = 'q';

char b = 'p';

cout<<"a="<

ps.Print();

}

问题一：以上程序存在三个错误，在不改变主函数内容的前提下，试改正该程序。#include

#include

using namespace std;

class CPerson

{

public:

void Print();

CPerson(int m,string n)

{

age=m;

name=n;

}

private:

int age;

string name;

};

void CPerson::Print()

{

cout<<"name="<

}

void main()

{

CPerson ps(23,"张三");

ps.Print();

}

3.2.2 程序设计

1．设计实现一个CPoint类，满足以下要求：

a．该类包含两个整型成员变量x（横坐标）和y（纵坐标），以及一个输出函数Print()用来输出横坐标和纵坐标，要求不可以在类的外部直接访问成员变量；

b．可以采用没有参数的构造函数初始化对象，此时的成员变量采用默认值0；

c．可以采用直接输入参数的方式来初始化该类的成员变量；

#include

using namespace std;

class CPoint{

public:

void print();

CPoint(){x=0;y=0;}

point(int x1,int y1);

int GetX() {return x;}

int GetY() {return y;}

private:

int x;

int y;

};

void CPoint::print()

{

cout<

}

CPoint::point(int x1,int y1)

{

x=x1;

y=y1;

}

void main()

{ CPoint p;

CPoint();

p.print();

p.point(1,2);

p.print();

p.GetX();

}

3.3思考题

1．设计一个CStudent（学生）类，并使CStudent类具有以下特点：

a．有学生姓名、学号、程序设计、信号处理、数据结构三门课程的成绩；

b．全部信息由键盘输入；

c．通过成员函数统计学生平均成绩，当课程数量增加时，成员函数无须修改仍可以求取平均成绩；

d．输出学生的基本信息、各科成绩与平均成绩；

e．学生对象用链表存储；

f．统计不及格学生人数。

#include

#define N 3

#define M 3

class CStudent

{

public:

void setstudent(char *name,char *sn,float score[N]);

void showstudent();

private:

char Sname[10];

char Sno[8];

float Score[3];

float Avg;

float Sum;

int count;

};

void CStudent :: setstudent(char *name,char *sn,float score[N])

{

int i;

float Sum=0.0;

int count=0;

strcpy(Sname,name);

strcpy(Sno,sn);

for(i=0;i

{

Score[i]=score[i];

count++;

}

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

{

Sum=Sum+Score[i];

}

Avg=Sum/count;

}

void CStudent ::showstudent()

{

int i;

cout<

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

cout<

}

void main()

{

int i,j,k=0;

char name[10],no[8];

float score[N];

for(j=1;j<=M;j++)

{

cout<<"please input student["<

cin>>name;

cout<<"please input student["<

cin>>no;

cout<<"please input student["<

for(i=0;i

cin>>score[i];

CStudent S1;

cout<<"student["<

cout<

S1.setstudent(name,no,score);

S1.showstudent();

if(score[i]<60)

k++;

}

cout<<"不及格人数:"<

}

实验五派生与继承—单基派生

5.1 实验目的

1．理解继承的概念；

2．理解公有派生、私有派生和保护派生；

3．理解单基派生类中构造函数和析构函数的执行顺序。

5.2 实验内容

5.2.1程序阅读

1．理解下面的程序并运行，然后回答后面的问题。#include "iostream.h"

class CBase

{

public:

CBase(int a)

:a(a)

{

}

protected:

void print()

{

cout<<"a="<

}

private:

int a;

};

class CDerive : public CBase

{

public:

void print()

{

CBase::print();

cout<<"b="<

}

private:

int b;

};

void main()

{

CDerive d;

d.print();

CBase b;

b.print();

}

问题一：以上程序有两个错误，试指出来，并改正之。

答：派生类CDerive中没有定义CDerive（），主函数中没有给d，b对象赋值。#include "iostream.h"

class CBase

{

public:

CBase(int a)

:a(a)

{

}

void print()

{

cout<<"a="<

}

private:

int a;

};

class CDerive : public CBase

{

public:

CDerive(int a,int c)

:CBase(a)

{

b=c;

}

void print()

{

CBase::print();

cout<<"b="<

}

private:

int b;

};

void main()

{

CDerive d(1,3);

d.print();

CBase b(2);

b.print();

}

2．理解下面的程序并运行，然后回答后面的问题。#include "iostream.h"

class CBase

{

public:

CBase(int a)

:a(a)

{

cout<<"base structure"<

}

~CBase()

{

cout<<"base destructure"<

}

void print()

{

cout<<"a="<

}

protected:

int a;

};

class CDerive : public CBase

{

public:

CDerive(int a, int b,int c)

:CBase(a),b(b),c(c)

{

cout<<"derive structure"<

}

~CDerive()

{

cout<<"derive destructure"<

}

void print()

{

CBase::print();

cout<<"b.a="<

cout<<"c="<

}

private:

CBase b;

int c;

};

void main()

{

CDerive d(1,2,3);

-----------------------------------------------------①

d.print();

}

问题一：以上程序的输出结果是什么，为什么？

答：程序错误，不能输出结果。“cout<<"b.a="<

问题二：①处语句执行完后，d.b.a的值为多少？

答：b.a=2。

实验七多态性—函数与运算符重载

7.1 实验目的

1．理解静态联编和动态联编的概念；

2．掌握成员函数方式运算符重载；

3．掌握友元函数方式运算符重载；

4．掌握++、--、=运算符的重载。

7.2 实验内容

7.2.1程序阅读

1．理解下面的程序并运行，然后回答后面的问题。

#include "iostream.h"

class CComplex

{

public:

CComplex()

{

real = 0;

imag = 0;

}

CComplex(int x,int y)

{

real = x;

imag = y;

}

int real;

int imag;

CComplex operator + (CComplex

obj1)-----------------------------------------------①{

CComplex obj2(real + obj1.real, imag + obj1.imag);

return obj2;

}

};

void main()

{

CComplex obj1(100,30);

CComplex obj2(20, 30);

CComplex obj;

obj = obj1+obj2;

------------------------------------------------------------------②cout << obj.real <

cout << obj.imag << endl;

}

问题一：①处的运算符重载，为什么该函数的返回值要设计成CComplex类型？

答：运算符重载函数的返回值与其操作类的类型相同。

问题二：②处的运算符重载函数调用就相当于“obj=operator+(obj1,obj2);”，请问CComplex 类中的运算符重载函数为什么只有一个参数？

答：因为另一个参数是隐含调用，是CComplex类的当前对象。它通过this指针隐含地进行传递。

2．理解下面的程序并运行，然后回答后面的问题。

#include "iostream.h"

class CComplex

{

public:

CComplex()

{

real = 0.0;

imag = 0.0;

}

CComplex(float x, float y)

{

real = x;

imag = y;

}

CComplex operator + (CComplex &obj1, CComplex &obj2)

{

CComplex obj3(obj1.real + obj2.real, obj1.imag + obj2.imag);

return obj3;

}

CComplex &operator++(CComplex &obj)

{

obj.real += 1;

obj.imag +=1;

return obj;

}

void print()

{

cout<

}

private:

float real;

float imag;

};

CComplex &operator--(CComplex &x)

{

x.real -= 1;

x.imag -= 1;

return x;

}

void main()

{

CComplex obj1(2.1,3.2);

CComplex obj2(3.6,2.5);

cout<<"obj1=";

obj1.print();

cout<<"obj2=";

obj2.print();

CComplex obj3 = obj1 + obj2;

cout<<"befor++, obj3=";

obj3.print();

++obj3;

cout<<"after++, obj3=";

obj3.print();

--obj3;

cout<<"after--, obj3=";

obj3.print();

CComplex obj4 = ++obj3;

cout<<"obj4=";

obj4.print();

}

问题一：以上程序中的三个运算符重载都有错误，试改正并分析输出结果。