C++上机考试题,上机练习,东南大学C++上机实验

定义一个复数类，通过重载运算符：=、+=、－=、+、－、*、/、= =、！=，
直接实现两个复数之间的各种运算。

编写一个完整的程序（包括测试各运算符的程序部分）。

*/
#include "stdio.h"//标准输入输出头文件
#include "iostream.h"
class Complex
{
float Real,Image;
public:
Complex(float r=0,float i=0)
{
Real=r;Image=i;
};
float GetR(){return Real;}
float GetI(){return Image;}//后面主函数要直接调用私有成员数据
void show(){cout<<"Real="<<Real<<'\t'<<"Image="<<Image<<endl;}
Complex operator +(Complex &);//把形参定义为引用，调用时更方便
void operator +=(Complex &);//自加运算，返回值为void
Complex operator -(Complex &);
void operator -=(Complex &);
Complex operator *(Complex &);
Complex operator /(Complex &);
void operator =(Complex &);
int operator !=(Complex &);
int operator ==(Complex &);//返回真假
};
Complex Complex::operator +(Complex &c)//此时的函数名变为Complex::operator
{
Complex t;//在函数体内可以定义新的类，并把这个临时的类返回，同样用打点来访问t.Real=Real+c.Real;
t.Image=Image+c.Image;
return t;
}
void Complex::operator +=(Complex &c)
{
Real=Real+c.Real;
Image=Image+c.Image;
}
Complex Complex::operator -(Complex &c) {
Complex t;
t.Real=Real-c.Real;
t.Image=Image-c.Image;
return t;
}
void Complex::operator -=(Complex &c)
{
Real=Real-c.Real;
Image=Image-c.Image;
}
Complex Complex::operator *(Complex &c) {
Complex t;
t.Real=Real*c.Real-Image*c.Image;
t.Image=Real*c.Image+Image*c.Real;
return t;
}
Complex Complex::operator /(Complex &c) {
Complex t;
t.Real=Real*c.Real+Image*c.Image;
t.Image=-Real*c.Image-Image*c.Real;
float val=c.Real*c.Real+c.Image*c.Image;
t.Real=t.Real/val;
t.Image=t.Image/val;
return t;
}
void Complex::operator =(Complex &c)
{
Real=c.Real;
Image=c.Image;
}
int Complex::operator !=(Complex &c)
{
int res;//函数体内定义临时变量
res=(c.Real!=Real)&&(c.Image!=Image);
return res;
}
int Complex::operator ==(Complex &c)
{
int res;
res=(c.Real==Real)&&(c.Image==Image);
return res;
}
void main()
{
Complex a(3,4),b(6,8),c,d;
c=a;//赋值=
c.show();
d=a+b;//+
d.show();
c=b-a;//-
c.show();
c=b;
c+=a;//+=
c.show();
d=b;
d-=a;//-=
d.show();
//
c=a;
d=a;
cout<<endl<<"输出c和d: \n";
if(c==d) {c.show();d.show();cout<<"c==d";}
c=b;
d=a;
cout<<endl<<"输出c和d: \n";
if(c!=d) {c.show();d.show();cout<<"c!=d";}
//
cout<<endl;
cout<<"a*b: ";
c=a*b;c.show();
cout<<"\na/b: ";
d=b/a;d.show();
}
//在函数体内可以定义新的类，并把这个临时的类返回，同样用打点来访问
/*
四、下标运算符[ ]通常用于取数组中某个元素，可以实现数组下标越界的检测等。

本题要求通过下标运算符的重载，实现读取数组中某个元素的作用。

它具有如下公有成员函数：
1. void Word (char *s ); 动态生成字符数组空间，用形参s来对其进行初始化。

2. char & operaror[ ](int n )给下标值为n的数组元素赋值。

下标运算符[ ]的重载关键是将下标值做为一个操作数。

它的实现非常简单，就是用字符指针的首地址str加下标值n，然后将相加后的地址返回。

3. void disp( ); 实现将字符指针str指向的字符串输出到屏幕上。

4. 用~ Word（）析构函数来释放动态申请的堆空间。

*/
# include<iostream.h>
# include<string.h>
class Word {
private :
char *str;
int len;
public :
Word(char *s) //void Word (char *s )把原题的void去掉，做构造函数
{
len=strlen(s)+1;
str=new char[len];
strcpy(str,s);
}
char & operator [](int n)//重载[]，用operator，返回值为引用类型
{ //n是[]的操作数，即下标
if(n>=0&&n<len-1)
return str[n];
else {
cout<<n<<"越界";
return str[len-1];
}
}
void disp() {
cout<<str<<endl;
}
~Word()
{
delete []str;
}
};
{
char *s="china";
Word w(s);//用字符串的指针做形参，做构造函数Word("china")
w.disp( );
int n=strlen(s);
while(n>0)
{
w[n-1]=w[n-1]-32;
n--;
}
w.disp( );
cout<<w[7];
}
// 14-3.cpp
/*建立一个双向链表，节点数据包括姓名、地址和工资，按工资从小到大的顺序排序。

参见教材P281 例12.7和教材P192页
*/
#include <iostream.h>
#include <string.h>
class Object
{
public:
Object(){};//可以定义空的构造函数
virtual int IsEqual(Object &)=0;//纯虚函数
virtual int IsBigger(Object *)=0;//形参为&，实参直接为变量名
//形参为*，实参为指针或地址virtual void Show()=0;
virtual ~Object(){};
};
class IntObj: public Object
{
int data;//工资
char *name;
char *address;
public:
IntObj(char *s=NULL,char *a=NULL,int x=0)
{
data=x;
{
name=new char[strlen(s)+1];//strlen的参数是指针
strcpy(name,s);
}
else name=NULL;
if(a)
{
address=new char[strlen(a)+1];
strcpy(address,a);
}
else address=NULL;
}
~IntObj()
{
if(name) delete [] name;//析构前预判，很重要
if(address) delete [] address;
}
void SetData(char *s,char *a,int x)//修改数据
{
data=x;
if(s)
{
delete [] name;//name本来指向另一个字符串，它开辟的空间长度
//需要人为改变,赋新的值之前要删除原有空间，重新开辟name=new char[strlen(s)+1];
strcpy(name,s);
}
else name=NULL;
if(a)
{
delete [] address;
address=new char[strlen(a)+1];
strcpy(address,a);
}
else address=NULL;
}
int IsEqual(Object &obj)
{
IntObj &temp=(IntObj &)obj;//为它起个别名
if(strcmp(name,)!=0) return 0;//用strcmp函数比较字符串是否相同
if(strcmp(address,temp.address)!=0) return 0;
if(data!=temp.data) return 0;
return 1;
}
int IsBigger(Object *obj)
{
IntObj *temp=(IntObj *)obj;
if(data<=temp->data) return 0;
else return 1;
}
void Show()
{
cout<<"姓名: "<<name<<'\t'<<"地址: "<<address<<'\t'<<"工资="<<data<<'\t'<<endl;
}
};
class Node//此处Node定义为类，前面都是定义为struct，这个节点当中包含为上面定义
//的类的数据成员
{
private:
Object *Info;//定义类object的指针
Node *Prev,*Next;//定义节点类型的指针，一前一后
public:
Node(){Info=0;Prev=Next=0;} //定义的指针在构造函数中初始化为0
Node(Node &node)//定义拷贝的构造函数
{
Info=;
Prev=node.Prev;
Next=node.Next;
}
void FillInfo(Object *obj){Info=obj;}
friend class List;
};
class List
{
Node *Head,*Tail;
public:
List(){Tail=Head=0;}
~List(){DeleteList();}
void AddNode(Node *);
Node *DeleteNode(Node *);
Node *LookUp(Object &);
void ShowList();
void DeleteList();
void InsertNode(Node *);
};
void List::AddNode(Node *node)
{
if(Head==0){
Head=Tail=node;
node->Next=node->Prev=0;
}
else{
Tail->Next=node;
node->Prev=Tail;
Tail=node;
node->Next=0;
}
}
Node *List::DeleteNode(Node *node)
{
if(node==Head)
if(node==Tail)
Head=Tail=0;
else{
Head=node->Next;
Head->Prev=0;
}
else{
node->Prev->Next=node->Next;
if(node!=Tail) node->Next->Prev=node->Prev;
else Tail=node->Prev;
}
node->Prev=node->Next=0;
return(node);
}
Node *List::LookUp(Object &obj)
{
Node *pn=Head;
while(pn)
{
if(pn->Info->IsEqual(obj)) return pn;
pn=pn->Next;
}
return 0;
}
void List::ShowList()
{
Node *p=Head;
while(p)
{
p->Info->Show();
p=p->Next;
}
}
void List::DeleteList()
{
Node *p,*q;
p=Head;
while(p)
{
delete p->Info;
q=p;
p=p->Next;
delete q;
}
}
void List::InsertNode(Node *p)
{
Node *pn=Head,*p1;
if(Head==0)//空表
{
Head=Tail=p;
Head->Next=Tail->Prev=0;
return ;
}
if(Head->Info->IsBigger(p->Info))//小于头节点
{
p->Next=Head;
Head->Prev=p;
Head=p;
return ;
}
pn=p1=Head;
while(pn->Next&&pn->Info->IsBigger(p->Info)==0)//寻找插入位置{
p1=pn;pn=pn->Next;
}
if(pn->Info->IsBigger(p->Info)==0)//最末尾
{
Tail->Next=p;
p->Prev=Tail;
Tail=p;
p->Next=0;//注意
}
else//一般情况//插入p1和pn之间
{
p->Prev=p1;
p1->Next=p;
pn->Prev=p;
p->Next=pn;
}
}
void main()
{
IntObj *p;
Node *pn,*pt,node;
List list;
char *name[]={"jack","tom","john","mary","Sun"};
char *address[]={"sh","bj","nj","sz","gz"};
for(int i=1;i<6;i++)
{
p=new IntObj(name[i-1],address[i-1],6-i+100);
pn=new Node;
pn->FillInfo(p);
list.InsertNode(pn);
}
list.ShowList();
cout<<"\n";
IntObj da;
da.SetData("tom","bj",104);
pn=list.LookUp(da);
if(pn) pt=list.DeleteNode(pn);
list.ShowList();
cout<<"\n";
if(pn) list.InsertNode(pt);
list.ShowList();
cout<<"\n";
}
/*本来指向另一个字符串，它开辟的空间长度需要人为改变,赋新的值之前要删除原有空间，重新开辟.
*/
/*
编写一个程序，输入N个学生数据，包括学号、姓名、C++成绩，
要求输出这些学生的数据、平均分与成绩等级。

提示：设计一个学生类Stud，除了包括id(学号)、name(姓名)和C(成绩)数据成员外，
还有两个静态成员数据sum和num，分别存放总分和人数，
另有两个普通成员函数setdata()和print()，分别用于给数据成员赋值和输出数据成员的值，另有一个静态成员函数avg()，它用于计算平均分，并输出平均分。

同时设计一个友元函数，输出成绩对应的等级：
大于等于90：优；80~90：良；70~79：中；60~69：及格；小于60：不及格。

在main()函数中定义了一个对象数组用于存储输入的学生数据，设计一个完整的程序。

*/
#include "stdio.h"
#include "iostream.h"
#include "string.h"
class Stud
{
int id;
char *name;
int cpp;
public:
static float sum,num;//定义两个静态成员数据，数值需要不断累加的sum，可以定义//为静态，使每次修改的值都可以被保留，相对地，定义它的静态成员函数Stud()
{
name=NULL;
num++;
};
~Stud()
{
if(name) delete [] name;
num--;
};
void setdata(char *s,int m_id,int m_cpp);
void print();
static float avg();
friend void printgrade(Stud &stu);//按题目要求，定义友元函数输出，可以
//访问类的任何成员
};
float Stud::sum=0;//定义静态变量，原型说明和定义型说明
float Stud::num=0;
void Stud::setdata(char *s,int m_id,int m_cpp)
{
name=new char[strlen(s)+1];
strcpy(name,s);
id=m_id;
cpp=m_cpp;
sum+=cpp;
}
float Stud::avg()//静态函数的定义型说明，此时不用加static对函数进行原型说明{
float res;
if(num>0) res=sum/num;
else cout<<"没有学生对象!";
return res;
}
void Stud::print()
{
cout<<"学号: "<<id<<" 姓名: "<<name<<" C++成绩: "<<cpp<<endl;
}
void printgrade(Stud &stu)
{
//cout<<"学号"<<stu.id<<" 姓名"<<<<"C++成绩等级: ";
cout<<"C++成绩等级: ";
if(stu.cpp>=90) cout<<"优"<<endl;
else if(stu.cpp>=80) cout<<"良"<<endl;
else if(stu.cpp>=70) cout<<"中"<<endl;
else if(stu.cpp>=70) cout<<"中"<<endl;
else if(stu.cpp>=60) cout<<"及格"<<endl;
else cout<<"不及格"<<endl;
}
void main()
{
int i,n;
char name[100];
int id,cpp;
cout<<"请输入学生个数: ";
cin>>n;
Stud *pstu=new Stud[n];
for(i=0;i<n;i++)
{
cout<<"请分别输入学号,姓名和C++成绩";
cin>>id>>name>>cpp;
pstu[i].setdata(name,id,cpp);
}
for(i=0;i<n;i++) {pstu[i].print();printgrade(pstu[i]);}
cout<<Stud::num<<"个学生平均分: "<<Stud::avg()<<endl;
}
/*
1. 实现描述超市的的类Suppermacket 类，记录系统中现有商品(用指针实现)，定义增加商品的函数Append ，删除商品的函数Delete ，查询商品的函数Query，
并显示查询结果；
2. 定义商品类Goods ，具有商品名称Name，商品价格Price，商品数量number等属性，操作Sale （销售商品，余额不足时给予提示）、Add（商品上架操作）
和ShowMe（显示商品信息）。

3. 编写main函数，测试以上所要求的各种功能，完成商品的增加、删除和查询商品，以及商品销售和商品上架的操作。

4. 可以利用对象成员来实现。

*/
#include<iostream.h>
#include<string.h>
class Suppermacket;
class Goods{
float Price;
int number;
char Name[10];
public:
Goods(){Add();};
void Sale();
void Add();
void ShowMe();
friend Suppermacket;
friend void Sale(Suppermacket &);
};
class Suppermacket{
Goods * PGoods[10];
public:
Suppermacket(){
for(int i=0;i<10;i++) PGoods[i]=0;
}
void Append();
void Delete();
void Query();
friend void Sale(Suppermacket &);
};
void Sale(Suppermacket &Goods);
void main(){
Suppermacket Goods;
Goods.Append();
Goods.Append();
Goods.Append();
Goods.Delete();
Goods.Query();
Sale(Goods);
}
void Goods::Sale(){
int n;
ShowMe();
cout<<"请输入购买的商品数量：";
cin>>n;
if(number>n) number-=n;
else cout<<"货物数量不足！";
}
void Goods::Add(){
cout<<"请输入新上架商品的名称，单价和数量：";
cin>>Name>>Price>>number;
}
void Goods::ShowMe(){
cout<<" 品名："<<Name<<" 数量："<<number<<"单价："<<Price<<endl; }
void Suppermacket::Append(){
int n=0;
while( PGoods[n]!=0 && n<10) n++;
if(n<10) PGoods[n]=new Goods;
}
void Suppermacket::Delete(){
char name[10];
cout<<"请输入待删除的商品名称：";
cin>>name;
for(int i=0;i<10;i++){
if(PGoods[i]==0) continue;
if(strcmp(PGoods[i]->Name,name)==0) break;
}
if(i<10) {
cout<<"删除"<<name<<"商品\n";
delete PGoods[i];PGoods[i]=0;
}
else cout<<"没有此类商品！\n";
}
void Suppermacket::Query(){
char name[10];
cout<<"请输入待查询的商品名称：";
cin>>name;
for(int i=0;i<10;i++) {
if(PGoods[i]==0)continue;
if(strcmp(PGoods[i]->Name,name)==0) break;
}
if(i>=10) {cout<<"没有此类商品！\n";
else PGoods[i]->ShowMe();
}
void Sale(Suppermacket &Goods){
char name[10];
int i=0;
cout<<"请输入待买的商品名称：";
cin>>name;
while(i<10) {
if(Goods.PGoods[i]==0) {i++;continue;}
if(strcmp(Goods.PGoods[i]->Name,name)==0) break;
i++;
}
if(i>=10) cout<<"没有此类商品！\n";
else Goods.PGoods[i]->Sale();
}
/*
【程序功能】找出给定范围内的和亲数。

对于两个正整数，如果其中的一个整数是另一个整数的全部真因子之和，反之亦然，则称这两个数为"和亲数"。

例如，220有真因子"1, 2, 4, 5, 10, 11, 20, 22, 44,
55, 110"，其和为284，而284有真因子"1, 2, 4, 71, 142"，其和为220，因此220和284就是一对和亲数。

【编程要求】
1. 试建立一个类NNM
私有数据成员
int n1 , n2 ;//查找数据的范围
int a[10][2]; //存储m n（m<n）之间的所有和亲数对，并存储到a数组中
int num; //统计和亲数对的个数
公有成员函数
1) 缺省构造函数：初始化数据成员n1,n2为0。

2) 带参构造函数NNM(int m,int n,int a[][2])：用参数初始化数据成员n1,n2。

3) void find( )函数用于查找n1 n2之间的所有和亲数对并存储到数组中
4) 打印函数void print( )，将结果输出到屏幕
*/
#include<iostream.h>
class NNM{
int n1,n2;
int a[10][2];
int num;
public:
NNM(){n1=0;n2=0;num=0;}
NNM(int a, int b){
n1=a,n2=b,num=0;
}
void find();
void print();
};
void main(){
NNM a(2,500);
a.find();
a.print();
}
void NNM::find(){
int sum1=0,sum2=0;
int i,n;
for(i=n1;i<=n2;i++){
for(sum1=0,n=1;n<i/2+1;n++)
if(i%n==0)sum1+=n;
for(sum2=0,n=1;n<sum1/2+1;n++)
if(sum1%n==0)sum2+=n;
if(sum2!=i || sum1==i) continue;
a[num][0]=i,a[num++][1]=sum1;
}
}
void NNM::print(){
for(int i=0;i<num;i++)
cout<<a[i][0]<<','<<a[i][1]<<endl;
}
/*
二. 【要求】试建立一个类Student 用于描述学生信息，具体要求如下：
私有数据成员
int id: 学生学号。

char yuwen: 语文成绩（五级分制：A、B、C、D和E，其它无效）。

float shuxue: 数学成绩（百分制）。

公有成员函数
1) 缺省构造函数：初始化数据成员为0或NULL值。

2) 带参构造函数：用参数初始化数据成员(需判断参数是否有效)。

3) void Print( ): 输出本对象的学号、语文成绩（优，良，中，及格，不及格）和数学成绩。

4) 修改函数void Change( )：从键盘输入新的学号、语文成绩和数学成绩，修改相应数据成员的值。

接受输入前屏幕上显示提示输入哪些信息。

5) 比较函数void Comp(Student &a, Student &b): 比较本学生、a学生和b学生的数学成绩，找出数学成绩最高和最低的学生，输出他们的信息。

主程序：定义三个以上的对象，并且每个成员函数至少被调用一次。

#include<iostream.h>
class Student{
int id; //学生学号。

char yuwen; //语文成绩（五级分制：A、B、C、D和E，其它无效）。

float shuxue; // 数学成绩（百分制）。

public:
Student(){id=0, yuwen=NULL;shuxue=0;}
Student(int,char,float);
void Print( );
void Change( );
void Comp(Student &a, Student &b);
};
void main(){
Student A(78,'E',86),B(84,'D',82),C;
C.Change();
p(B,C);
}
Student::Student(int a,char b, float c){
id=a, yuwen=b;shuxue=c;
}
void Student::Print( ){
cout<<" 学号: "<<id<<",语文成绩: "
<<yuwen<<",数学成绩: "<<shuxue<<endl;
}
void Student::Change( ){
cout<<"请输入学生的学号、语文成绩(五级分制：A/B/C/D/E，其它无效)和数学成绩：\n";
cin>>id>>yuwen>>shuxue;
}
void Student::Comp(Student &a, Student &b){
Student max,min;
max= shuxue>a.shuxue?(shuxue>b.shuxue? *this:b):(a.shuxue>b.shuxue?a:b);
min= shuxue<a.shuxue?(shuxue<b.shuxue? *this:b):(a.shuxue<b.shuxue?a:b);
cout<<"数学成绩最高和最低的学生分别是：\n";
max.Print();
min.Print();
}
/*
1. 实现描述超市的的类Suppermacket类，记录系统中现有商品(用指针实现)，定义增加商品的函数Append，删除商品的函数Delete，查询商品的函数Query，
显示查询结果；
2. 定义商品类Goods，具有商品名称Name，商品价格Price ，商品数量number 等属性，操作Sale（销售商品，余额不足时给予提示）、Add（商品上架操作）
和ShowMe（显示商品信息）。

3. 编写main函数，测试以上所要求的各种功能，完成商品的增加、删除和查询商品，以及商品销售和商品上架的操作。

4. 可以利用对象成员来实现。

*/
#include<iostream.h>
#include<string.h>
class Suppermacket;
class Goods{
char name[10];
int Price;
int number;
public:
Goods(){
strcpy(name,"");Price=0;number=0;}
void Sale(int n);
void Add();
void ShowME(){
cout<<"商品："<<name<<",价格："<<Price<<"，有"<<number<<"件。

\n\n";
};
friend Suppermacket;
};
class Suppermacket{
Goods *PGoods;
int num;
public:
Suppermacket(int n=10){
PGoods=new Goods[n];
num=n;
}
void Append();
void Delete();
void Query();
~Suppermacket(){
delete [] PGoods;}
};
void main(){
Suppermacket A(3);
A.Append();
A.Append();
A.Delete();
A.Query();
}
void Suppermacket::Append(){
for(int i=0;i<num;i++){
if(PGoods[i].number==0){
PGoods[i].Add();
PGoods[i].ShowME();
return;
}
}
cout<<"没有空货架上货了！\n";
}
void Suppermacket::Delete(){
char name[10];int n;
cout<<"请输入需要销售商品名称和数量: ";
cin>>name>>n;
for(int i=0;i<num;i++){
if(strcmp(PGoods[i].name,name)==0){
PGoods[i].Sale(n);
return;
}
}
cout<<"查无此商品!\n";
}
void Suppermacket::Query(){
char name[10];
cout<<"请输入需要查询的商品名称; ";
cin>>name;
for(int i=0;i<num;i++){
if(strcmp(PGoods[i].name,name)==0){
PGoods[i].ShowME();
return;
}
}
cout<<"查无此商品!\n";
}
void Goods::Sale(int n){
if(n<number){
number-=n;
ShowME();
}
else
cout<<"商品数量不够，无法销售！\n";
}
void Goods::Add(){
cout<<"请输入上架的商品名称、价格及数量: ";
cin>>name>>Price>>number;
}
/*
1. 建立一个类NUM，求指定范围内的所有素数（质数）。

具体要求如下：
1) 私有数据成员。

int data[25]；依次存放指定范围内的所有素数。

int spanl , span2 ；存放要求计算的素数的范围。

int num ；存放span1与span2之间的素数个数。

2) 公有成员函数。

构造函数NUM (int a ,int b)；初始化所要求的素数的范围span1、span2及num (值为0)。

void process( ): 求出指定范围内的所有素数，把它们依次存放在数组data中，并将求出的素数的个数赋给num 。

void print( )：输出求出的所有素数。

3) 在主程序中对该类进行测试。

使用测试数据span1=100 , span2=200 。

即求100~200之间的所有素数。

*/
#include<iostream.h>
#include<math.h>
class NUM{
int data[25]; //依次存放指定范围内的所有素数。

int span1,span2; //存放要求计算的素数的范围。

int num; //存放span1与span2之间的素数个数。

public:
NUM (int a ,int b);
void process( );
void print( );
};
void main(){
NUM a(100,200);
a.process();
a.print();
}
NUM::NUM (int a ,int b){
span1=a;
span2=b;
num=0;
}
void NUM::process( ){
int i,n,f=0;
for(i=span1;i<=span2;i++){
for(n=2,f=0;n<=sqrt(i);n++)
if(i%n==0){f=1;break;}
if(f==1)continue;
data[num++]=i;
}
}
void NUM::print( ){
for(int i=0;i<num;){
cout<<data[i]<<'\t';
if(++i%6==0)cout<<endl;
}
cout<<endl;
}
/*
已知由一个数组派生出另一个数组的派生规则如下：假定原始数组为a[10]，新数组为b[10]，则b[i]的值为数组a中大于a[i]的元素的个数。

例如，对于说明"int a[ ]={1,2,3,4,5}；int b[5]；"，其中a[1]=2，数组a中有3个元素比a[1]大，则b[1]=3。

试建立一个实现此功能的类ARRAY。

具体要求如下：
1) 私有数据成员。

int a[10],b[10]；a存放原始数组，b存放派生数组。

2) 公有成员函数。

构造函数ARRAY（int data[10]）；初始化成员数组a 。

void process( )；由数组a根据上述派生类规则，用循环语句计算数组b的各元素。

void print( )；屏幕显示数组a和b。

*/
#include<iostream.h>
class ARRAY{
int a[10],b[10];
public:
ARRAY(int data[10]);//初始化成员数组a 。

void process( );//由数组a根据上述派生类规则，用循环语句计算数组b的各元素。

void print( );//屏幕显示数组a和b。

};
void main(){
int a[]={7,4,9,23,56,44,18,33,21,17};
ARRAY array(a);
array.process();
array.print();
}
ARRAY::ARRAY(int data[10]){
for(int i=0;i<10;i++){
a[i]=data[i];
b[i]=0;
}
}
void ARRAY::process( ){
for(int i=0;i<10;i++){
for(int k=0;k<10;k++)
if(a[k]>a[i]) b[i]++;
}
}
void ARRAY::print( ){
cout<<"a[10]= ";
for(int i=0;i<10;i++)
cout<<a[i]<<' ';
cout<<endl;
cout<<"b[10]= ";
for(i=0;i<10;i++)
cout<<b[i]<<' ';
cout<<endl;
}
/*
【要求】按以下描述和要求建立一个类Boxes，执行主函数对其测试。

私有成员：
int *box ; //指向保管箱数组，下标为箱号，元素值为0表示空箱；大于0表示该箱中存入的物品数量。

char *flag ; //指向客户标识符数组（下标为箱号,与box数组配对使用）
static int sum; //累计存入物品数量
公有成员：
Boxes(int num=10); //构造函数，动态分配box和flag数组空间, 长度为num。

~Boxes( ); //析构函数，释放分配的内存
void put(int n, char m); //选择一个空箱存入n件物品，填写客户标识符，并将物品数量累加到sum；若找不到空箱则输出提示信息。

void get(char m); //根据客户标识符（元素下标）查找存储的物品，找到后取出并清空保管箱（置0）。

若找不到指定则输出提示信息。

void display(); //输出保管箱类所有数据，统计占用箱个数和空闲箱个数。

最后输出存入
物品数量
头文件包含语句为：#include <iostream.h>
在类定义外面对静态成员做定义性说明并赋初值为零：int Boxes::sum=0;
主函数要求：
1) 定义Boxes类对象A, B(2)。

数组元素初始值为零。

2) 调用函数put为对象A和B做存储操作：
A.put(5, 'R');
B.put(9,'K');
A. put(8, 'P');
B. put(15, 'H');
B. put(40, 'F');
调用函数display输出对象A和B的全部数据。

3) 调用函数put和get为对象A和B做存储和取出操作：
B. get('H');
B. put(40, 'F');
A. get('S') ;
A. get('R');
A. put(12, 'M');
4) 调用函数display输出对象A和B的全部数据。

*/
#include<iostream.h>
class Boxes{
int *box ; //指向保管箱数组，下标为箱号，元素值为0表示空箱；大于0表示该箱中存入的物品数量。

char *flag ; //指向客户标识符数组（下标为箱号,与box数组配对使用）
static int sum; //累计存入物品数量
int xh;
public:
Boxes(int num=10); //构造函数，动态分配box和flag数组空间, 长度为num。

~Boxes( ); //析构函数，释放分配的内存
void put(int n, char m); //选择一个空箱存入n件物品，填写客户标识符，并将物品数量累加到sum；若找不到空箱则输出提示信息。

void get(char m); //根据客户标识符（元素下标）查找存储的物品，找到后取出并清空保管箱（置0）。

若找不到指定则输出提示信息。

void display(); //输出保管箱类所有数据，统计占用箱个数和空闲箱个数。

最后输出存入物品数量
};
int Boxes::sum=0;
void main(){
Boxes A,B(2);//数组元素初始值为零。

A.put(5, 'R');
B.put(9,'K');
A. put(8, 'P');
B. put(15, 'H');
B. put(40, 'F');
cout<<"A库：\n";A.display();
cout<<"B库：\n";B.display();
B. get('H');
B. put(40, 'F');
A. get('S') ;
A. get('R');
A. put(12, 'M');
cout<<"A库：\n";A.display();
cout<<"B库：\n";B.display();
}
Boxes::Boxes(int num){
box=new int[num];
flag=new char[num];
xh=num;
for(int i=0;i<num;i++)
box[i]=flag[i]=0;
}
Boxes::~Boxes( ){
delete []box;
delete []flag;
}
void Boxes::put(int n, char m){
int i=0;
while(box[i]!=0 && i++<xh);
if(i<xh && box[i]==0) {
box[i]=n;flag[i]=m; s um+=n;
}
else cout<<"无空箱存放客户"<<m<<"的物品!\n\n"; }
void Boxes::get(char m){
int i=0;
while(flag[i]!=m && i<xh) i++;
if(flag[i]!=m)
cout<<"没有找到客户"<<m<<"物品!\n\n";
}
void Boxes::display(){
int n=0;
for(int i=0;i<xh;i++)
if(box[i]>0)
cout<<" 客户"<<flag[i]<<"：存放物品数量："<<box[i]<<"件。

\n";
else n++;
cout<<"占用箱个数："<<xh-n<<"个,空闲箱个数："<<n<<"个。

\n存入物品总数量有："<<sum<<"\n\n";
}
/*
1. 建立一个矩阵类Array，存储一个n×n矩阵并能完成矩阵转置运算。

要求如下：（1）私有成员数据
int *x：指向存储一个n×n矩阵值的内存区域（二维数组作为一维数组存储）
int n：存储矩阵行数
（2) 公有成员函数
构造函数：用参数指定的值或缺省值3初始化n，并用n的值为矩阵动态申请内存空间；析构函数：释放对象存储矩阵时占用的内存空间；
viod input(int *a)：将一个矩阵赋值给对象中的数组。

void print()：按行输出矩阵的值。

void change()：转置矩阵。

编写一个程序测试该类。

定义对象A，将一个矩阵存入A中，并输出矩阵的值，转置对象A 中的矩阵并输出，使用以下测试数据：
A＝A转置后的矩阵＝
1 2 3 4
5 6 7 8
9 10 11 12
13 14 15 16
*/
#include<iostream.h>
#define N 4
class Array{
int *x; //指向存储一个n×n矩阵值的内存区域（二维数组作为一维数组存储）
int n; //存储矩阵行数
public:
Array(int s=3){
n=s;
x=new int[N*N];
}
void input(int *a);//将一个矩阵赋值给对象中的数组。

void print();//按行输出矩阵的值。

void change();//转置矩阵。

~Array(){
if(x) delete []x;
}
};
void main(){
int a[N][4];
int i,j;
cout<<"请输入"<<N<<'*'<<N<<"的矩阵"<<endl;
for(i=0;i<N;i++){
for(j=0;j<N;j++)
cin>>a[i][j];
}
Array d(N);
d.input(a[0]);
cout<<"原始数组为：\n";
d.print();
d.change();
cout<<"转置后的数组为：\n";
d.print();
}
void Array::input(int *a){
for(int i=0;i<N*N;i++)
x[i]=*a++;
}
void Array::print(){
for(int i=0;i<N*N;i++)
((i+1)%4)?cout<<x[i]<<'\t':cout<<x[i]<<endl; }
void Array::change(){
int temp;
for(int i=0;i<N;i++)
for(int j=0;j<i;j++){
temp=x[i*N+j];
x[i*N+j]=x[j*N+i];
x[j*N+i]=temp;
}
}
/*
模拟人脑神经网络的神经元结构模型如下图所示：
其中，xi表示输入信号，wi表示输入信号的加权系数，y表示神经元的输出，它们的之间的关系为：
这里，∑表示各项的和，exp（z）为求z的自然指数值ex的函数，包含在头文件math.h 中，其函数原型为double exp(double z)。

试定义一个NN类实现上述模型。

具体要求如下：
1）私有成员
float x[5]，dt：数组x和数组w分别存放输入信号xi及其加权系数wi；dt存放非零参数σ。

double y：神经元的突出。

2）公有成员：
NN（float t[ ] , float d）用数组t初始化加权系统wi，用d初始化dt。

void fun(float t[ ])：用数组t初始化xi，并根据上述公式计算y的值。

void print( )：输出输入信号和输出信号的值
在主函数中，用输入信号{1.2，3.5 , 2.3 , 3.2 , 2.8 } 以及加权系数{ o.5 , 0.8 , 1.2 , 1.8 , 1.1 }对该类进行测试。

*/
#include<iostream.h>
#include<math.h>
class NN{
float x[5],w[5],dt;
double y;
public:
NN(float t[],float d);//用数组t初始化加权系统wi，用d初始化dt。

void fun(float t[]); //用数组t初始化xi，并根据上述公式计算y的值。

void print( ); //输出输入信号和输出信号的值
};
void main(){
float a[5]={1.2,3.5,2.3,3.2,2.8};
float b[5]={0.5,0.8,1.2,1.8,1.1};
NN t(b,0.2);
t.fun(a);
t.print();
}
NN::NN(float t[],float d){
for(int i=0;i<5;i++)
w[i]=t[i];
dt=d;
}
void NN::fun(float t[]){
for(int i=0;i<5;i++)
x[i]=t[i];
double n=0.0;
for(i=0;i<5;i++)
n+=(x[i]-w[i])*(x[i]-w[i]);
y=exp(-n/(2*dt*dt));
}
void NN::print(){
cout<<"x[i]=";
for(int i=0;i<5;i++)
cout<<x[i]<<' ';
cout<<endl;
cout<<"y="<<y<<endl;
}
/*
3. 面向对象编程：几何图形类
【要求】按以下描述和要求建立两个类：基类Rectangle和派生类Cube：Rectangle:
私有成员：
double x1, y1 ; //左下角的坐标
double x2, y2 ; //右上角的坐标
公有成员
Rectangle(double a=0, double b=0, double c=0, double d=0);
//带缺省值的构造函数
double getwidth(); //计算并返回矩形的宽
double getlength() ; //计算并返回矩形的长
virtual void display() ; //输出矩形的各坐标及长宽
注：正立方体Cube的底面矩形从基类继承
Cube：
私有成员：
string name; //立方体名称（字符串对象）
double h; //立方体高度
公有成员：
Cube (string="", double =0, ……); //带缺省值的构造函数
void set (string, double) ; //修改立方体标识符和高度值
void display(); // 输出立方体全部信息，并计算输出体积
Cube add ( Cube &S ); //将参数对象S的高度加到this对象上。

以上成员函数的参数名如有未给出的则自已命名。

头文件包含语句为：
#include <iostream.h>
#include <string.h>
主函数要求：
（1）定义Rectangle类对象A{坐标:10, 10, 30, 40}；
定义Cube类对象B{坐标:20, 10, 30, 40；名称和高度: Box, 60}、C（C数据由B拷贝生成）和D（D数据暂无）。

（2）调用函数set修改对象C的名称和高度值。

数据为{ Trunk, 95}。

（3）调用函数display及相关函数输出对象A、B和C的全部数据，计算输出B和C的体积。

每个对象的信息占一行。

（4）调用add函数，计算D=B+C。

输出D的全部数据，计算并输出D的体积。

*/
#include<iostream.h>
#include<string.h>
class Rectangle{
double x1, y1 ; //左下角的坐标
double x2, y2 ; //右上角的坐标
public:
Rectangle(double a=0, double b=0, double c=0, double d=0){
x1=a,y1=b;x2=c,y2=d;
}
double getwidth(){return (x2-x1);} //计算并返回矩形的宽
double getlength(){return (y2-y1);} //计算并返回矩形的长
void display() ; //输出矩形的各坐标及长宽
};
class Cube :public Rectangle{
char name[10]; //立方体名称（字符串对象）
double h; //立方体高度
public:
Cube (double a=0,double b=0,double c=0,double d=0,
char *s=0, double h1=0):Rectangle(a,b,c,d){//带缺省值的构造函数
if(s) strcpy(name,s);
h=h1;
}
void set (char *, double);//修改立方体标识符和高度值。