友元函数实验报告

课程名称：VC++程序设计

专业名称

班级

学号

姓名

实验（4）：

实验日期

【实验名称】

友元

【实验目的】

1）了解为什么要使用友元

2）掌握友元函数、友元成员、友元类的定义和使用方法

【实验内容和结果】

1. 定义复数complex类，使用友元，完成复数的加法、减法、乘法、除法运算，以及对复数的输出。

#include

using namespace std;

//复数加法公式：

//复数减法公式：

//复数乘法公式：

//复数除法公式：

class complex{

double real;

double image;

public:

complex(double r=0,double i=0){

real=r;

image=i;

}

friend void inputcomplex(complex&com);

friend complex addcomplex(complex&c1,complex&c2);

friend complex subcomplex(complex&c1,complex&c2);

friend complex mulcomplex(complex&c1,complex&c2);

friend complex divcomplex(complex&c1,complex&c2);

friend void outputcomplex(complex&com);

};

void inputcomplex(complex &com){

cin>>com.real>>com.image;

}

complex addcomplex(complex&c1,complex&c2){

complex c;

c.real=c1.real+c2.real;

c.image=c1.image+c2.image;

return c;

}

complex subcomplex(complex&c1,complex&c2){

complex c;

c.real=c1.real-c2.real;

c.image=c1.image-c2.image;

return c;

complex mulcomplex(complex&c1,complex&c2){ complex c;

c.real=c1.real*c2.real-c1.image *c2.image;

c.image=c1.real*c2.image+c1.image*c2.real;

return c;

}

complex divcomplex(complex&c1,complex&c2){ complex c;

int divisor=c2.real*c2.real+c2.image*c2.image;

if(!divisor)

{

cout<<"不能被0除"<

exit(-1);

}

c.real=(c1.real*c2.real+c1.image*c2.image)/divisor;

c.image=(c1.image*c2.real-c2.image*c1.real)/divisor;

return c;

}

void outputcomplex(complex &com){

if(com.real)

{cout<<"("<

if(com.image>0)

cout<<"+"<

else if(com.image<0)

cout<

cout<<")";

return;

}

else

cout<<"("<

}

int main(){

complex c1,c2,result;

cout<<"请输入第一个复数的实部和虚部："<

cout<<"请输入第二个复数的实部和虚部："<

inputcomplex(c2);

result=addcomplex(c1,c2);

outputcomplex(c1);

cout<<"+";

outputcomplex(c2);

cout<<"=";

outputcomplex(result);

cout<<"\n*******************************"<

result=subcomplex(c1,c2);

outputcomplex(c1);

cout<<"-";

outputcomplex(c2);

cout<<"=";

outputcomplex(result);

cout<<"\n*******************************"<

result=mulcomplex(c1,c2);

outputcomplex(c1);

cout<<"*";

outputcomplex(c2);

cout<<"=";

outputcomplex(result);

cout<<"\n*******************************"<

result=divcomplex(c1,c2);

outputcomplex(c1);

cout<<"/";

outputcomplex(c2);

cout<<"=";

outputcomplex(result);

cout<<"\n*******************************"<

return 0;

}

实验结果为：

请输入第一个复数的实部和虚部：

4.2 7.4

请输入第二个复数的实部和虚部：

9.4 7.8

(4.2+7.4i)+(9.4+7.8i)=(13.6+15.2i)

*******************************

(4.2+7.4i)-(9.4+7.8i)=(-5.2-0.4i)

*******************************

(4.2+7.4i)*(9.4+7.8i)=(-18.24+102.32i)

*******************************

(4.2+7.4i)/(9.4+7.8i)=(0.652349+0.24698i)

*******************************

Press any key to continue

2.定义矩阵类，使用友元实现矩阵的常用运算。

#include

#include

using namespace std;

class Matrix

{

int row,col;

int*p;

public :

Matrix(int i=1,int j=1)

{

row=i;

col=j;

p=new int[row*col];

}

int getRow()

{

return row;

}

int getCol()

{

return col;

}

Matrix(const Matrix&ref)

{

row=ref.row;

col=ref.col;

p=new int[row*col];

for(int i=0;i

{

p[i]=ref.p[i];

}

}

void operator=(const Matrix&ref)

{

row=ref.row;

col=ref.col;

p=new int[row*col];

for(int i=0;i

{

p[i]=ref.p[i];

}

}

~Matrix()

{

delete []p;

}

friend void input(Matrix&);

friend void display(Matrix&);

friend Matrix add(Matrix&,Matrix&);

friend Matrix sub(Matrix&,Matrix&);

friend Matrix mul(Matrix&,Matrix&);

};

void input(Matrix& a)

{

cout<<"请输入该矩阵的"<

for (int i=0;i

cin>>a.p[i];

}

void display(Matrix &a)

{

int conter=0;;

for (int i=0;i

cout<

conter++;

if(conter%a.col==0)

cout<

}

}

Matrix add(Matrix& a,Matrix& b)

{

Matrix result(a.row,a.col);

for (int i=0;i

result.p[i]=a.p[i]+b.p[i];

return result;

}

Matrix sub(Matrix& a,Matrix& b)

{

Matrix result(a.row,a.col);

for (int i=0;i

result.p[i]=a.p[i]-b.p[i];

return result;

}

Matrix mul(Matrix& a,Matrix& b)

{

int i,j,k;

Matrix result(a.row,b.col);

for (i=0;i

result.p[i]=0;

for(i=0;i

for(j=0;j

for(k=0;k

result.p[i*b.col+j]+=a.p[i*a.col+k]*b.p[k*b.col+j];

return result;

}

int main()

{

int row,col;

cout<<"请输入第一个矩阵的行数和列数："<

cin>>row>>col;

Matrix a(row,col);

input(a);

cout<<"请输入第二个矩阵的行数和列数："<

cin>>row>>col;

Matrix b(row,col);

input(b);

//显示两个矩阵

cout<<"第一个矩阵为："<

display(a);

cout<<"第二个矩阵为："<

display(b);

Matrix result;

if(a.getRow()||a.getCol()!=b.getCol())

{

cout<<"这两个矩阵不能做加法和减法"<

}

else

{

result=add(a,b);

cout<<"两个矩阵的和为："<

display(result);

result=sub(a,b);

cout<<"两个矩阵的差为："<

display(result);

}

if(a.getCol()!=b.getRow())

{

cout<<"这两个矩阵不能做乘法"<

}

else

{

result=mul(a,b);

cout<<"两个矩阵的积为："<

display(result);

}

return 0;

}

实验结果为：

请输入第一个矩阵的行数和列数：

3 2

请输入该矩阵的6个元素值:

5 4 2 8

6 8

请输入第二个矩阵的行数和列数：

2 1

请输入该矩阵的2个元素值:

2 8

第一个矩阵为：

5 4

2 8

6 8

第二个矩阵为：

2

8

这两个矩阵不能做加法和减法

两个矩阵的积为：

42

68

76

Press any key to continue

3.实现堆栈的压入和弹出。定义两个类，一个是结点类，它包含结点值和指向上一结点的指针；另一个类实堆栈类，数据成员为堆栈的头指针，它是结点类的友元。

#include

using namespace std;

class stack;

class node

{

int data;

node*prev;

public:

node(int d,node*n)

{

data=d;

prev=n;

}

friend class stack;

};

class stack

{

node*top;

public:

stack()

{

top=0;

}

void push(int i);

int pop();

};

void stack::push(int i)

{

node*n=new node(i,top);

top=n;

}

int stack::pop()

{

node*t=top;

if(top)

{

top=top->prev;

int c=t->data;

delete t;

return c;

}

return 0;

}

int main()

{

int c;

stack s;

cout<<"请输入10个数字："<

for(int i=0;i<10;i++)

{

cin>>c;

s.push(c);

}

cout<<"堆栈弹出的序列为："<

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

cout<

return 0;

}

实验结果为：

请输入10个数字：

0 1 2 3 4 5 6 7 8 9

堆栈弹出的序列为：

9876543210Press any key to continue 【思考与体会】

【老师打分与签名】