一、 定义复数类，要求：
     （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;
}