今天同学找我给做C++作业 觉得这几个题还挺有意思的就发上来。。。

一、 定义复数类，要求：
（1）属性定义为私有数据成员；
（2）定义2个重载的构造函数：1）由参数传入实部（虚部默认为0），2）由参数传入实部和虚

部；
（3）为私有数据成员定义getXXX、setXXX函数；
（4）定义显示信息函数，使用IO流显示对象的复数表示；
（5）定义加、减、乘、除函数，实现2个复数的四则运算功能；
（6）在主函数中，创建复数类的对象，对各个成员函数进行测试。
二、定义Person类，属性包括：姓名、性别、出生年月、家庭住址、籍贯。要求：
（1）属性定义为私有数据成员；
（2）定义构造函数；
（3）为私有数据成员定义getXXX、setXXX函数；
（4）定义显示信息函数，使用IO流显示对象的所有属性值；
（5）在主函数中，创建Person类的对象，对各个成员函数进行测试。
三、 定义Student类，要求：
（1）从Person类公有派生；
（2）定义构造函数；
（3）为新增的数据成员定义getXXX、setXXX函数；
（4）定义显示信息函数，使用IO流显示对象的所有属性值；
（5）在主函数中，创建Person类的对象，对各个成员函数进行测试。
四、定义一个函数模板，实现对int、float等各种基本数据类型的数组进行从大到小的排序。要求：
（1）数组大小及元素由参数传入；
（2）在主函数中，使用int、float等各种基本数据类型的数组测试实例化后的模板函数。
五、定义类模板Vector，描述向量。要求：
（1）向量长度在创建对象时才指定，存储空间使用new、delete进行动态管理；
（2）定义多个重载的构造函数，分别满足:默认情况下（长度为0）、只传入长度参数、同时传

入长度和内容等情况下对象的创建；
（3）定义私有数据成员的getXXX、setXXX函数；
（4）定义成员函数，实现向量的显示、查找、排序功能；
（5）在主函数中，使用int、float、char等各种基本数据类型实例化模板，并对各模板类的各

个成员函数进行测试。

1.
#include <iostream>
using namespace std ;
class Plural //复数类
{

public :
int getValueA() ;
int getValueB() ;
void setValue(float valueA,float valueB);
Plural(float valueA); //构造函数1
Plural(float valueA,float valueB) ; //构造函数2
void showValue() ; //显示函数
Plural operator+(Plural tem) //运算符重载
{
Plural t(this->valueA+tem.valueA,this->valueB+tem.valueB) ;
return t;
}
Plural operator-(Plural tem)
{
Plural t(this->valueA-tem.valueA,this->valueB-tem.valueB) ;
return t;
}
Plural operator*(Plural tem)
{
Plural t(this->valueA*tem.valueA,this->valueB*tem.valueB) ;
return t;
}
Plural operator/(Plural tem)
{
Plural t(this->valueA/tem.valueA,this-

>valueB/tem.valueB) ;
return t;
}

private :
float valueA; //实部
float valueB;//虚部
};
Plural::getValueA()
{
return this->valueA ;
}
Plural::getValueB()
{
return this->valueB ;
}
void Plural::setValue(float valueA,float valueB)
{
this->valueA=valueA ;
this->valueB=valueB ;
}
void Plural::showValue()
{
cout<<this->valueA<<"+"<<this->valueB<<"i"<<endl;
}
Plural::Plural(float valueA,float valueB)
{
this->valueA=valueA;
this->valueB=valueB;

}
Plural::Plural(float valueA)
{

this->valueA=valueA;
this->valueB=0 ;

}
int main(int argc,char**grgv)
{
Plural a(1,2) ;
Plural b(3,4) ;
Plural c=a+b;
c.showValue();
c.setValue(3,6) ;
c.showValue() ;
c.



return 0 ;
}

2.3. //在一起
#include <iostream>
using namespace std ;
class Person
{
public :
Person(char*name,char*sex,char*birth,char*addr,char*jiguan)
{
strcpy(this->name,name) ;
strcpy(this->sex,sex) ;
strcpy(this->birth,birth) ;
strcpy(this->addr,addr) ;
strcpy(this->jiguan,jiguan) ;
}*
Person()
{
}
void setInfo(char*name,char*sex,char*birth,char*addr,char*jiguan) //设置信息
{
strcpy(this->name,name) ;
strcpy(this->sex,sex) ;
strcpy(this->birth,birth) ;
strcpy(this->addr,addr) ;
strcpy(this->jiguan,jiguan) ;
}
Person getInfo() //返回this指向的对象
{
return *this;
}
void showInfo()
{
cout<<"name:"<<this->name<<endl;
cout<<"sex:"<<this->sex<<endl ;
cout<<"birth:"<<this->birth<<endl;
cout<<"addr:"<<this->addr<<endl;
cout<<"jiguan:"<<this->jiguan<<endl;
}
private :
char name[10] ;
char sex[5] ;
char birth[15];
char addr[20] ;
char jiguan[10] ;
} ;

class Student :public Person
{

public :
Student(char*name,char*sex,char*birth,char*addr,char*jiguan,int

number,char*major)
{
Person::setInfo(name,sex,birth,addr,jiguan);
this->number=number;
strcpy(this->major,major);
}

void showInfo()
{
Person::showInfo() ;
cout<<"学号:"<<number<<endl ;
cout<<"专业:"<<major<<endl ;

}
Student getInfo() //返回本对象副本
{
return *this ;
}
private :
int number ;//学号
char major[20] ;//专业
} ;

void main(int argc,char**argv)
{

Student s("d","f","w","we","fw",56,"ds");
s.showInfo();

}

4.
#include <iostream>
using namespace std ;
template<class T> //模板函数
void sort(T value[],int len)
{
T tem ;//中间变量
for(int i=0;i<len-1;i++)
for(int j=i+1;j<len;j++)
if(value[j]>value[i])
{
tem=value[j];
value[j]=value[i];
value[i]=tem ; //冒泡排序
}
}
void main(int argc,char**argv)
{

int num[6]={2,34,7,9,1,5};
int len=sizeof(num)/sizeof(int);
sort(num,len) ;
for(int i=0;i<6;i++)
cout<<num[i]<<" " ;
}

4.

#include <iostream>
using namespace std ;
template <class T>
class Vector
{
public :
Vector(int len)
{
length=len ;
list=new T[len] ;
}
Vector()
{
length=0 ;
list=NULL ;
}
~Vector() //析构函数
{
delete []list; //防止堆中内存泄露 释放内存
cout<<"内存释放成功"<<endl;

}
Vector(int len,T *num)
{
length=len ;
list=new T[length];
for(int i=0;i<length;i++)
this->list[i]=num[i];
}
void ShowVector() //显示 向量
{
for(int i=0;i<length;i++)
cout<<list[i]<<" " ;
cout<<endl ;
}
void FindValue(T value) //查找元素返回索引位置
{
for(int i=0;i<length;i++)
if(value==list[i])
{
cout<<"找到元素"<<value<<",位于第"<<i+1<<"个数字"<<endl ;
return ;
}
cout<<"没有找到元素!"<<endl ;
}
T getAt(int index) //通过索引返回数据
{
if(index>length)
{
cout<<"越界返回-9999"<<endl;
return (T)-9999; //如果越界 返回
}
return list[index];
}
void setAt(int index,T value) //通过索引设置指定位置的数据
{

if(index>length)
{
cout<<"越界"<< endl;
return ;
}
list[index]=value ;
}
void sort() //排序 升序
{
T tem ;//临时中间变量
for(int i=0;i<length-1;i++)
for(int j=i+1;j<length;j++)
{
if(list[j]<list[i])
{
tem=list[j];
list[j]=list[i];
list[i]=tem ;
}
}

}
private:
T *list ;
int length ;
};
void main(int argc,char**argv)
{

cout<<"int型测试:"<<endl;
int num1[8]={2,6,8,0,2,3,1,5};
Vector<int> *a=new Vector<int>(8,num1) ; //测试了带两个参数的构造函数 剩下2中自

己测试
a->ShowVector() ;
a->setAt(2,88) ; //根据索引为每个元素赋值
a->ShowVector();
cout<<a->getAt(3)<<endl ;//通过索引返回指定位置元素
a->FindValue(4) ;//查找元素
a->sort();
cout<<"整形排序后:"<<endl;
a->ShowVector();


cout<<endl<<"float型测试:"<<endl;
float num2[4]={3.3f,4.2f,5.7f,6.1f};
Vector<float> *b=new Vector<float>(4,num2) ; //测试了带两个参数的构造函数 剩下2

中自己测试
b->ShowVector() ;
b->setAt(2,88.3f) ; //根据索引为每个元素赋值
b->ShowVector();
cout<<b->getAt(3)<<endl ;//通过索引返回指定位置元素
b->FindValue(3.3f) ;//查找元素
b->sort();
cout<<"浮点型排序后:"<<endl;
b->ShowVector();

cout<<endl<<"char型测试:"<<endl;
char num3[4]={'a','f','4','r'};
Vector<char> *c=new Vector<char>(4,num3) ; //测试了带两个参数的构造函数 剩下2中

自己测试
c->ShowVector() ;
c->setAt(2,'h') ; //根据索引为每个元素赋值
c->ShowVector();
cout<<c->getAt(3)<<endl ;//通过索引返回指定位置元素
c->FindValue('a') ;//查找元素
c->sort();
cout<<"字符型排序后:"<<endl;
c->ShowVector();

delete a;
delete b;
delete c;
}