[关闭]
@Pinetrie 2019-06-20T16:23:54.000000Z 字数 6702 阅读 1033

实验五

1、 录入下面程序，并分析结果：

  1. #include   <iostream>
  2. #include   <complex>
  3. using namespace   std;
  5. class Base
  6. {
  7. public:
  8.     Base() {cout<<"Base-ctor"<<endl;}
  9.     ~Base() {cout<<"Base-dtor"<<endl;}
  10.     virtual void f(int){cout<<"Base::f(int)"<<endl;}
  11.     virtual void f(double){cout<<"Base::f(double)"<<endl;}
  12.     virtual void g(int i=10){cout<<"Base::g()"<<i<<endl;}
  13. };
  14. class Derived : public Base
  15. {
  16. public:
  17.     Derived() {cout<<"Derived-ctor" <<endl;}
  18.     ~Derived(){cout<<"Derived-dtor"<<endl;}
  19.     void f(complex<double>) {
  20.         cout<<"Derived::f(complex)"<<endl;
  21.     }
  22.     void g(int   i=20){
  23.         cout<<"Derived::g()"<<i<<endl;
  24.     }
  25. };
  26. int main()
  27. {
  28.     cout<<sizeof(Base)<<endl;
  29.     cout<<sizeof(Derived)<<endl;
  31.     Base b;
  32.     Derived d;
  33.     Base *pb=new Derived;
  34.     b.f(1.0);
  35.     d.f(1.0);
  36.     pb->f(1.0);
  37.     b.g();
  38.     d.g();
  39.     pb->g();
  40.     delete   pb;
  41.     return 0;
  42. }

2、 录入下面程序，并分析结果：

  1. #include   <iostream>
  2. using   namespace   std;
  3. class   Base
  4. {
  5. public:
  6.     Base():data(count)
  7.     {
  8.         cout<<"Base-ctor"<<endl;
  9.         ++count;
  10.     }
  11.     ~Base()
  12.     {
  13.         cout<<"Base-dtor"<<endl;
  14.         --count;
  15.     }
  16.     static int count;
  17.     int data;
  18. };
  19. int Base::count;
  20. class Derived  : public Base
  21. {
  22. public:
  23.     Derived():data(count),data1(data)
  24.     {
  25.         cout<<"Derived-ctor"<<endl;
  26.         ++count;
  27.     }
  28.     ~Derived()
  29.     {
  30.         cout<<"Derived-dtor"<<endl;
  31.         --count;
  32.     }
  33.     static int count;
  34.     int data1;
  35.     int data;
  36. };
  37. int Derived::count=10;
  38. int main()
  39. {
  40.     cout<<sizeof(Base)<<endl;
  41.     cout<<sizeof(Derived)<<endl;
  43.     Base* pb = new Derived[3];
  44.     cout<<pb[2].data<<endl;
  45.     cout<<((static_cast<Derived*>(pb))+2)->data1<<endl;
  46.     delete[] pb;
  48.     cout<<Base::count<<endl;
  49.     cout<<Derived::count<<endl;
  50.     return 0;
  51. }

3、 录入下面程序，修改错误。

  1. #include <iostream>
  2. #include <new>
  3. #include <assert.h>
  4. using namespace std;
  5. class Abstract
  6. {
  7. public:
  8.     Abstract()  {cout << "in Abstract()"<<endl;}
  9.     virtual void f() = 0;
  10. };
  11. class Subclass : public Abstract
  12. {
  13. public:
  14.     Subclass()  {cout << "in Subclass()"<<endl;}
  15.     void f()  {cout << "Subclass::f()"<<endl;}
  16. };
  17. int main()
  18. {
  19.     Abstract *p = new Subclass;
  20.     p->f();
  21.     return 0;

4、 定义基类shape类为一个表示形状的抽象类

  1. #include <iostream>
  2. #include <cmath>
  3. using namespace std;
  5. const double PI = 3.14;
  7. class shape
  8. {
  9. public:
  10.     virtual double area() = 0;
  11. };
  13. class triangle:public shape
  14. {
  15. public:
  16.     triangle(double a,double b,double c):a(a),b(b),c(c) {}
  17.     double area()
  18.     {
  19.         double p = (a + b + c) / 2;
  20.         return sqrt(p * (p - a) * (p - b) * (p - c));
  21.     }
  22. private:
  23.     double a,b,c;
  24. };
  26. class circles:public shape
  27. {
  28. public:
  29.     circles(double r):r(r) {}
  30.     double area()
  31.     {
  32.         return r * r * PI;
  33.     }
  34. private:
  35.     double r;
  36. };
  38. int main()
  39. {
  40.     shape *p;
  41.     triangle t(3,4,5);
  42.     circles c(10);
  43.     p=&t;
  44.     cout<<"triangle area:"<<p->area()<<endl;
  45.     p=&c;
  46.     cout<<"circles area:"<<p->area()<<endl;
  47.     return 0;
  48. }

5、 定义一个抽象类Base和派生类Derived

  1. #include <iostream>
  2. using namespace std;
  4. class Base
  5. {
  6. public:
  7.     virtual void abstractMethod() = 0;
  8. };
  10. class Derived:public Base
  11. {
  12. public:
  13.     void abstractMethod()
  14.     {
  15.         cout<<"Derived::abstractMethod is called"<<endl;
  16.     }
  17. };
  19. int main()
  20. {
  21.     Base* pBase = new Derived;
  22.     pBase->abstractMethod();
  23.     delete pBase;
  24.     return 0;
  25. }

第六次作业

1、 教材习题6_20：实现一个简单圆类

  1. #include <iostream>
  2. #include <cmath>
  3. using namespace std;
  5. const double Pi = 3.14;
  7. class SimpleCircle
  8. {
  9. public:
  10.     void init(double r)  {p = &r;}
  11.     void showarea()  {cout<<(*p) * (*p) * Pi;}
  12.     void showr()  {cout<<*p;}
  13. private:
  14.     double *p = NULL;
  15. };
  17. int main()
  18. {
  19.     SimpleCircle A;
  20.     A.init(10);
  21.     cout<<"Area:";
  22.     A.showarea();
  23.     //A.showr();//
  25.     return 0;
  26. }

2、教材习题7_5：Shape类派生Rectangle和Circle类

  1. #include <iostream>
  2. using namespace std;
  4. class Shape
  5. {
  6. public:
  7.     Shape(double a,double b):a(a),b(b) {}
  8.     Shape(double a):a(a) {}
  9.     double geta()  {return a;}
  10.     double getb()  {return b;}
  11. private:
  12.     double a,b;
  13. };
  15. class Rectangle:public Shape
  16. {
  17. public:
  18.     Rectangle(double a,double b):Shape(a,b) {}
  19.     double getArea()
  20.     {
  21.         return geta() * getb();
  22.     }
  23. };
  25. class Circle:public Shape
  26. {
  27. public:
  28.     Circle(double a):Shape(a) {}
  29.     double getArea()
  30.     {
  31.         return geta() * geta() * 3.14;
  32.     }
  33. };
  35. int main()
  36. {
  37.     double a,b,r;
  38.     cout<<"Input a,b:";
  39.     cin>>a>>b;
  40.     cout<<"Input r:";
  41.     cin>>r;
  42.     Rectangle X(a,b);
  43.     Circle Y(r);
  44.     cout<<"Rectangle Area:"<<X.getArea()<<",Circle Area:"<<Y.getArea()<<endl;
  45.     return 0;
  46. }

3、 教材习题7_6：哺乳动物类Mammal派生出狗类Dog

  1. #include <iostream>
  2. #include <string>
  3. using namespace std;
  5. class Mammal
  6. {
  7. public:
  8.     Mammal(string name):name(name) {cout<<"Con.Mammal"<<endl;}
  9.     ~ Mammal()  {cout<<"Des.Mammal"<<endl;}
  10.     string getname()  {return name;}
  11. private:
  12.     string name;
  13. };
  15. class Dog:public Mammal
  16. {
  17. public:
  18.     Dog(string name):Mammal(name) {cout<<"Con.dog:"<<getname()<<endl;}
  19.     ~ Dog()  {cout<<"Des.dog:"<<getname()<<endl;}
  20. };
  22. int main()
  23. {
  24.     cout<<"Input Dog Name:";
  25.     string name;
  26.     cin>>name;
  27.     Dog A(name);
  28.     return 0;
  29. }

第11次作业

1、教材习题9_1：利用数组类模板Array解决学生成绩问题

  1. #include <cassert>
  2. #include <iostream>
  3. using namespace std;
  5. //数组类模板定义
  6. template <class T>
  7. class Array {
  8. private:
  9.     T* list;    //T类型指针，用于存放动态分配的数组内存首地址
  10.     int size;    //数组大小（元素个数）
  11. public:
  12.     Array(int sz = 50);            //构造函数
  13.     Array(const Array<T> &a);    //复制构造函数
  14.     ~Array();    //析构函数
  15.     Array<T> & operator = (const Array<T> &rhs); //重载"="使数组对象可以整体赋值
  16.     T & operator [] (int i);    //重载"[]"，使Array对象可以起到C++普通数组的作用
  17.     const T & operator [] (int i) const;    //"[]"运算符的const版本
  18.     operator T * ();    //重载到T*类型的转换，使Array对象可以起到C++普通数组的作用
  19.     operator const T * () const;    //到T*类型转换操作符的const版本
  20.     int getSize() const;    //取数组的大小
  21.     void resize(int sz);    //修改数组的大小
  22. };
  24. //构造函数
  25. template <class T>
  26. Array<T>::Array(int sz) {
  27.     assert(sz >= 0);    //sz为数组大小（元素个数），应当非负
  28.     size = sz;    // 将元素个数赋值给变量size
  29.     list = new T [size];    //动态分配size个T类型的元素空间
  30. }
  32. //析构函数
  33. template <class T>
  34. Array<T>::~Array() {
  35.     delete [] list;
  36. }
  38. //拷贝构造函数
  39. template <class T>
  40. Array<T>::Array(const Array<T> &a) {
  41.     //从对象x取得数组大小，并赋值给当前对象的成员
  42.     size = a.size;
  43.     //为对象申请内存并进行出错检查
  44.     list = new T[size];    // 动态分配n个T类型的元素空间
  45.     //从对象X复制数组元素到本对象
  46.     for (int i = 0; i < size; i++)
  47.         list[i] = a.list[i];
  48. }
  50. //重载"="运算符，将对象rhs赋值给本对象。实现对象之间的整体赋值
  51. template <class T>
  52. Array<T> &Array<T>::operator = (const Array<T>& rhs) {
  53.     if (&rhs != this) {
  54.         //如果本对象中数组大小与rhs不同，则删除数组原有内存，然后重新分配
  55.         if (size != rhs.size) {
  56.             delete [] list;        //删除数组原有内存
  57.             size = rhs.size;    //设置本对象的数组大小
  58.             list = new T[size];    //重新分配n个元素的内存
  59.         }
  60.         //从对象X复制数组元素到本对象
  61.         for (int i = 0; i < size; i++)
  62.             list[i] = rhs.list[i];
  63.     }
  64.     return *this;    //返回当前对象的引用
  65. }
  67. //重载下标运算符，实现与普通数组一样通过下标访问元素，并且具有越界检查功能
  68. template <class T>
  69. T &Array<T>::operator[] (int n) {
  70.     assert(n >= 0 && n < size);    //检查下标是否越界
  71.     return list[n];            //返回下标为n的数组元素
  72. }
  74. template <class T>
  75. const T &Array<T>::operator[] (int n) const {
  76.     assert(n >= 0 && n < size);    //检查下标是否越界
  77.     return list[n];            //返回下标为n的数组元素
  78. }
  80. //重载指针转换运算符，将Array类的对象名转换为T类型的指针，
  81. //指向当前对象中的私有数组。
  82. //因而可以象使用普通数组首地址一样使用Array类的对象名
  83. template <class T>
  84. Array<T>::operator T * () {
  85.     return list;    //返回当前对象中私有数组的首地址
  86. }
  88. template <class T>
  89. Array<T>::operator const T * () const {
  90.     return list;    //返回当前对象中私有数组的首地址
  91. }
  93. //取当前数组的大小
  94. template <class T>
  95. int Array<T>::getSize() const {
  96.     return size;
  97. }
  99. // 将数组大小修改为sz
  100. template <class T>
  101. void Array<T>::resize(int sz) {
  102.     assert(sz >= 0);    //检查sz是否非负
  103.     if (sz == size)    //如果指定的大小与原有大小一样，什么也不做
  104.         return;
  105.     T* newList = new T [sz];    //申请新的数组内存
  106.     int n = (sz < size) ? sz : size;    //将sz与size中较小的一个赋值给n
  107.     //将原有数组中前n个元素复制到新数组中
  108.     for (int i = 0; i < n; i++)
  109.         newList[i] = list[i];
  110.     delete[] list;        //删除原数组
  111.     list = newList;    // 使list指向新数组
  112.     size = sz;    //更新size
  113. }
  115. int main()
  116. {
  117.     int n;
  118.     cout<<"Input n:";
  119.     cin>>n;
  120.     Array<double> a(n);
  121.     cout<<"Input scores:";
  122.     for(int i = 0;i < n;i++)  cin>>a[i];
  123.     double sum = 0;
  124.     for(int i = 0;i < n;i++)  sum += a[i];
  125.     cout<<"Average:"<<sum / n<<endl;
  126.     return 0;
  127. }

2、教材习题9_10：利用插入排序函数模板进行排序

  1. #include <iostream>
  2. using namespace std;
  3. //用直接插入排序法对数组A中的元素进行升序排列
  4. template <class T>
  5. void insertionSort(T a[], int n) {
  6.     int i, j;
  7.     T temp;
  9.     //将下标为1～n-1的元素逐个插入到已排序序列中适当的位置
  10.     for (int i = 1; i < n; i++) {
  11.         //从a[i - 1]开始向a[0]方向扫描各元素,寻找适当位置插入a[i]
  12.         int j = i;
  13.         T temp = a[i];
  14.         while (j > 0 && temp < a[j - 1]) {
  15.             //逐个比较，直到temp >= a[j - 1]时，j便是应插入的位置。
  16.             //若达到j == 0，则0是应插入的位置。
  17.             a[j] = a[j - 1];    //将元素逐个后移，以便找到插入位置时可立即插入。
  18.             j--;
  19.         }
  20.         //插入位置已找到，立即插入。
  21.         a[j] = temp;
  22.         for(int k=0;k<n;k++)
  23.         {
  24.             cout<<a[k]<<" ";
  25.         }
  26.         cout<<endl;
  27.     }
  28. }
  31. int main()
  32. {
  33.     int data[]={1,3,5,7,9,11,13,15,17,19,2,4,6,8,10,12,14,16,18,20};
  34.     insertionSort(data,20);
  35.     return 0;
  36. }
添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注