1. C++语言基础

1.1 函数

C++新增：多态

• 函数重载（ overload ）

• 函数重写（覆写，overrride）

编译器会根据实参的类型来⾃动确定调⽤哪个重载函数

C++新增：内联函数

修饰关键字：inline

作用：编译时直接将函数替换为一堆代码，减少函数调用带来的开销。

比#define安全

成员函数默认内联，即使不写inline；外部函数必须加inline才能内联。

内存分配管理

每一个函数在栈空间上都有一段栈帧，保存这当前函数所需的变量等。当函数出栈时，这些成员也随之销毁。

1.2 const修饰符

const修饰的对象、变量，在运行过程中不能修改其值。

const int a = 1;        
a = 2;   // 错误！
// 会报错：error: assignment of read-only variable 'a'

注意：常量必须在声明时被初始化 const int a; // 错误！

关于const可修改的练习：

例1

int main() {
    const int a = 1;
    int* add = &a;   // 这一句有语法问题：invalid conversion from 'const int*' to 'int*'
    *add = 2;
    return 0;
}

编译器在做隐式转换的时候不会添加或删除const修饰，如果类型不匹配会报语法错误。

正确做法：使用强制类型转换，消除语法问题

int main() {
    const int a = 1;
    int* add = (int*)&a;  // 正确
    *add = 2;
    return 0;
}

编译器不会自作主张修改const修饰，因为可能有潜在风险，但是如果人为地强制转化，说明是程序员告诉编译器：“就这么干，我说的！“。编译器就会很放心地让程序员来承担责任，不会报错 /doge

注意：这里a为局部变量，即使被const修饰，也保存在栈上（假设没有常量折叠）。如果换做全局变量，被const修饰后存储在常量区中，为只读属性，没有办法修改的。

例2：指针变量也是变量，所以可用const修饰

常量指针

int main() {
    char array[] = {'a', 'b', 'c', 'd', '\0'};
    char* const name = array;    // 注意这里的 * 和 const的前后位置
    name[0] = 'H';               // 正确
    name = (char*)"Hi";          // 错误！ assignment of read-only variable 'name'
    return 0;
}

指向常量的指针

int main() {
    char array[] = {'a', 'b', 'c', 'd', '\0'};
    char const* name = array;    // 注意这里的 * 和 const的前后位置
    name[0] = 'H';               // 错误！
    name = (char*)"Hi";          // 正确
    return 0;
}

这里可以这样子去记忆：const负责在他左边的东西，如果左边是char*，说明地址是常量，如果左边是char，说明字符是常量。

1.3 动态内存分配

常规的静态分配内存：int a[10] = {0};

数组a在编译的时候就被分配了固定大小的内存。

int n = 10;
int b[x];   // 对于多数编译器是不允许的,即使允许也会有⻛险，如多线程编程

而使用动态定义变量更灵活

int n = 10;
int* b = new int[n]();

注意：最后记得delete

1.4 作用域运算符::

• 使用类的静态成员

• 解除被隐藏全局函数或变量

  int num = 1;  // 全局变量
  main() {
      int num = 2;            // 局部变量
      cout << num << endl;    // 显示局部变量
      cout << ::num << endl;  // 显示全局变量
  }
  

2. 类和对象

注意点：

• （C++11之前）在类体中不允许对数据成员进行初始化

  class A {
      int a = 0;   // 在一些老版本的编译环境上会出错
  };
  

• 类中的成员不能是自身类的对象

  否则会导致无限递归，最终栈溢出，因此会报编译错误。

  但是可以放自身类的指针或引用。

• 若类A中含有成员类B，则类B需要提前声明

• 数据成员不能用auto、register、extern修饰；成员函数不能用extern修饰

2.1 拷贝构造函数

注意点：

• 形参必须是对象的引用，&不能省略，否则会向上文所述的无限递归。

• 编译构造优化

• 要特别注意浅拷贝的问题

  举个例子

  class A {
      char* name;
      ~A() { delete[] name; }
  };
  

  当调用拷贝构造函数的时候，编译器会无脑复制一份数据到新对象，此时两个对象中name指向同一个地址，当两个类调用析构函数时，name会被delete两次，第二次会出错。

  这种情况必须自己写拷贝构造函数。

• 对象作为参数传递时，用引用或者指针好一点，可以避免一次拷贝构造，减少开销

2.2 静态成员

作用：为了解决同类对象间的数据共享问题，实际就是共享变量

静态成员在整个内存中只有一份，位于静态区。

在编译器遇到初始化语句时，就为其分配空间。

两种初始化方法：

• 在类内初始化：必须加static修饰符
• 在类内声明，要加static；在类外初始化，不加static

静态成员函数只能访问静态成员，因为非静态成员有对象才存在；相反，非静态成员函数可任意访问静态、非静态成员。在⼀般的成员函数中都隐含有⼀个this指针，⽤来指向对象自身，而在静态成员函数中没有this指针，这是无法访问非静态成员的技术原因。但是若向静态函数中传入对象，则可以访问对象中的非静态成员。

2.3 友元

允许⼀个类授权另⼀个类的对象（友元类）、某个成员函数（友元成员）或外部函数（友元函数）访问其对象的非公有成员，而不允许整个程序访问。是类的封装性与执行效率的折中。

Java保留了静态成员，舍弃了友元机制。

2.4 对象嵌套

比如类A中有成员变量类B，则在实例化A的时候，先调用B的构造函数，再调用A的构造函数（先里后外）

另外，在A的构造函数中，推荐使用构造函数初始化列表，来初始化B。

3. 派生类

重定义（隐藏）redefining：派生类中重新定义基类成员，包括数据成员、成员函数，可参考
重写（覆盖）overload：是重定义，但使用虚函数，实现了多态
在java中两者无区别

​ 派生类重新定义了print，则派生类中有两个print，但隐藏了继承来的print——用派生类对象a调用print，即a.print()，调用的是重新定义的，除非a.person::print();或者用基类指针指向a，用指针调用print。如果是重写，则根据虚表直接找到重写的print。

3.1 派生方式

这里比较绕，分三步说明

1）权限变化

• 公有派生中，权限不变。公有 -> 公有，私有 -> 私有，保护 -> 保护
• 私有派生中，all -> 私有

2）类内访问权限

• 基类的公有和保护成员都能够被派生类的成员访问

• 基类的私有成员不能被派生类成员直接访问，但可以通过基类的公有成员函数间接访问，比如基类的get、set

3）类外访问权限

​ 指的是实例化派生类后，能否通过a.print()的方式访问类内成员

​ 从类外看，派生类和基类是融为一体的，就当作一个普通的类操作，所以当然是私有不能访问，公有可以访问，而具体是私有还是公有见 1）中分析

综上所述，派生方式只改变类外访问权限

3.2 派生类构造、析构函数

派生类不继承构造函数，因为不符合构造方法的命名规则。但调用派生类构造函数时，编译器也要调用基类构造函数，这不是真正意义上的继承。析构函数也是类似。
但基类析构函数可以在子类中用基类名显式调用

注意：C++基类的析构函数一般定义为虚函数，防止内存泄漏

执行顺序

创建派生类对象：
(1)先执行基类的构造函数
(2)执行派生类的构造函数

销毁派生类对象时，相反

如何传参

• 如果基类的构造函数没有参数，或者没有显式地定义构造函数的时候，派生类构造函数不必考虑向基类构造函数传递参数，甚至可以不定义构造函数
• 当基类中带有参数的构造函数的时候，派生类必须定义构造函数，且使用初始化列表传递参数

3.3 重新定义

3.4 多重继承

派生类有多个基类，派生方式可以各不相同

构造顺序

 A    基类
/ \
B  C
\ /
 D
 
构造顺序为 ABACD

但是多继承可能有模糊性（菱形继承的二义性） 。此外，从不同类继承同名成员，也会出现歧义性

3.5 虚拟继承

class 派生类名 : virtual 派生方式 基类名{
	// .....
};

编译器保证从虚基类中继承的成员只有一个拷贝，避免模糊性

一些语法规定

 A    基类
/ \
B  C     BC继承A时需要虚继承
\ /
 D		 D不需要虚继承

也就是说，虚继承可以作用于一分为二的继承，避免基类成员也一分为二。而在合二为一的情况下，虚继承没有用

​ 在D的构造函数中，需要用参数化列表调用ABC的构造函数，即在直接继承BC基础上，加一个虚基类（祖先）的构造函数。因此，BC在继承A的时候，必须是公有继承，不然D无法调用A的构造函数，因此虚继承必须是公有继承。

构造顺序

上图调用顺序为ABCD，虚基类（祖先）第一个调用，并且只会调用一次，从而保证其成员只会被初始化一次。当然，如果虚基类还有父类，那应该按正常流程先调用父类，再子类。然后，虚继承的类先构造，非虚继承的类后构造

即：

1. 虚基类或非虚基类的祖先的构造函数
2. 任何虚继承基类的构造函数按照它们被继承的顺序构造
3. 任何非虚继承基类的构造函数按照它们被继承的顺序构造
4. 对象成员的构造函数
5. 派生类自己的构造函数

析构顺序相反

构造顺序 例1

A
|
B (C) D (E)
 \ |  | /
    F

其中F虚继承于CE，用括号表示，并包含一个M类成员
class F : public B, virtual public C, public D, virtual public E {
	// ...
	M mem1;
}

则构造顺序为：CEABDMF

构造顺序 例2

class A {
   public:
    int a;
    A() { a = 10; }
};

class A1 : virtual public A {
   public:
    A1() { a++; }
};

class A2 : virtual public A {
   public:
    A2() { a++; }
};

class B : public A1, public A2 {
   public:
    B() { a++; }
    void print() { cout << a << endl; }
};

int main() {
    B b;
    b.print();
    return 0;
}

结果输出：13

补充

虚基表

C++对象模型详解(整理)

图说C++对象模型：对象内存布局详解

C++:30 --- C++类成员，成员函数的内存布局

虚继承和虚基类的对象模型

大部分编译器都提供了查看C++代码中类内存分布的工具，比如vs。参考

1. 虚基类的直接子类（Veichle_Road、Veichle_Water）存放指向虚基类表的指针，以及自己新定义成员。
2. 后续子类（Amphicar）继承了两个父类的成员，包括虚基类表指针，并存放了虚基类成员（weight）的一个拷贝。

4. 多态性(polymorphism)

4.1 编译多态和运行多态

• 重载（Overload）：不同函数使用同一个函数名，即同样的接口实现不同的操作
• 重写（Override）：对虚函数的重新定义，即有继承关系的 不同类对象 对同一消息作出不同响应
• 重新定义（Redefining）：在派生类中定义一个新的
• 运算符重载
• 模板

联编

• 静态联编：在编译阶段进行联编，速度快、效率高，但不灵活
• 动态联编：在程序运行阶段进行联编，即直到程序运行时在确定调用哪个函数

在C++中：
函数重载（含运算符重载、重新定义、模版）是通过静态联编实现的
虚函数多态性（重写）是通过动态联编来实现的，使用虚函数表在运行时实现

举个例子

用来体会一下静态联编

class Point {
   public:
    Point(double i, double j) {
        x = i;
        y = j;
    }
    double Area() const { return 0.0; }   // 
   private:
    double x, y;
};

class Rectangle : public Point {
   public:
    Rectangle(double i, double j, double k, double l);
    double Area() const { return w * h; }  // 在派生类中重新定义
   private:
    double w, h;
};

Rectangle::Rectangle(double i, double j, double k, double l) : Point(i, j) {
    w = k;
    h = l;
}

void fun(Point& s) {  // 外部函数
    cout << s.Area() << endl;
}

void main() {
    Rectangle rec(3.0, 5.2, 15.0, 25.0);
    fun(rec);
    rec.Area();
}

注意fun函数的形参为Point&，即基类引用，因此会窄化，fun始终调用基类的Area()。若参数改为：Rectangle &s，也同样只能调用Rectangle中的Area()

4.2 函数重载

不同函数使用同一个函数名，由编译器来选择具体由哪个函数来执行

4.3 运算符重载

一般用于操作类，比如两个自定义类的 “+” 运算

显然，重载的运算符函数必须要能访问类中元素，因此运算符重载 要么是成员函数，要么是外部友元函数。如果用成员函数，那形参只有一个，如果是友元函数，形参有两个。特别的，( )、[ ]、->、=，必须用成员函数实现运算符重载，<<（输出）必须用友元函数实现运算符重载。

有一些运算符是不能重载的，共5个：. .* :: ?:（三目运算符） sizeof

对于[]、<<，都是两目，但区别是第一个参数是本类对象或其它类对象，所以采用不同实现方法，原因：

• 如果用成员函数实现，类的this指针会被绑定到运算符的左侧对象，防止出现异常的写法。这是与this的背后实现有关：比如a.f()，编译器先用this指向对象a，然后调用函数f，函数中访问数据成员时，编译器通过this到对象中找。对于a[i]的重载，[]是函数，所以仍遵循上述原理。

• 如果是友元，则没有this指针，双目运算符左右对象无限制，比如第一形参是整型（下标），第二形参是对象。可能导致：3[a] 。可参考

• 每个非静态成员函数都有一个隐式参数（编译器编译器编译时自动添加的），这个参数就是成员函数中this指针的来源，并且是第一个参数。
  比如：void A::f() {} ，实际上是：void A::f(A *const this) {} 编译器在编译时会自动传递参数，使得成员函数可以访问对象的数据成员。因为数据成员分配在对象中，而成员函数本类对象共用，分配在别的地方。
  << 运算符重载函数要求第一个参数必须是std:：ostream & ，所以必须是非成员函数。但不一定非得是友元，除非访问私有成员

关于编译优化

在值返回的时候会有所区别

Integer operator+(const Integer& a) {  // 情况1：返回局部对象
    return Integer(val + a.val);
}

Integer operator+(const int x) {  // 情况2：返回局部对象
    Integer tmp;                  
    tmp.val += x;
    return tmp;
}

Integer operator+(const char x) {  // 情况3：用*this返回
    return *this;
}

Integer operator-(const Integer x) {  // 情况4：返回形参对象
    return x;
}

在上述12两种返回局部对象的情况时，按理来说，应该是在return时创建一个匿名对象，再调用拷贝构造函数将其赋值给调用运算符的左值。而编译器会对此优化，不需要拷贝构造。

因此，上述四种情况分别会

1. 一次普通构造
2. 一次普通构造
3. 一次拷贝构造
4. 两次拷贝构造 （形参到实参也要一次）

增量运算符的重载

Integer& operator++( );  //前缀增量运算符
Integer operator++(int); //后缀增量运算符

​ 前缀与后缀在调用时其实形式一样，为了在调用时能够区分前、后缀，c++后来（开始时前后缀无区分）规定：后缀函数加一个没有实际意义的int参数，这样编译器在判断出前后缀时，就知道调用哪一个了。在调用后缀函数时，自动传给参数int的值是0，所以该参数的变量名都可以省略

​ 前缀按语义可连接，后缀不允许。此外后缀要先返回后加加，故返回对象。非要返回引用当然也可以，但会造成连续加加，不符合语义。

类型转换运算符重载

通过构造函数进行（简单类型 -> 类对象）

通过类型转换运算符重载进行（类对象-> 简单类型）

如operator int();

Integer::operator int() {
    cout << “Type changed to int” << endl;
    return value;  // 没返回类型，但要返回
}

注意：没有返回类型、参数

• 没有返回类型，因为强制转换为int说明int就是返回类型，再写一遍多此一举
• 没有参数，因为强制转换为单目运算符，加之用成员函数实现

赋值运算符重载

如果不重载，编译器会默认一个，其默认行为是复制对象的数据成员，就和默认拷贝构造函数一样，但这会导致浅拷贝

赋值运算符重载不能继承。实际是可继承，但因为派生类没定义赋值重载，则编译器默认一个，隐藏了继承来的

4.4 虚函数

动态联编实现的运行时多态

通常用基类指针（或引用）指向公有派生类对象。必须是公有派生，如果私有派生的话，从基类继承的成员都会私有，再拿基类指针指，首先会窄化，结果什么都访问不到。因此如果用基类指针指向私有、保护派生类对象，会直接在编译的时候报错

虚函数定义

在基类中被关键字virtua修饰，派生类中virtual可省略

这里的virtual和前文的虚继承一点关系都没有，同名纯属巧合

实现原理

​ 一个类有虚函数，则会定义虚函数表，本类只有一个。本类对象中都有虚函数表指针。虚函数表是函数指针数组，指向每个虚函数。

​ 派生类继承了虚函数，则也继承了虚函数表（复制了虚函数表）。如果重写虚函数，则修改虚表中函数指针，否则仍指向基类虚函数。

​ 编译阶段创建对象及类的虚表。运行时用基类指针访问到派生类对象，找到其虚表指针，查表找到虚函数执行。所以编译时只绑定了指针（包括对象中的虚函数表指针、虚函数表中的函数指针），运行时根据指针才能绑定虚函数。
​ 所以无论基类指针指向基类对象还是派生类对象，能做到不同对象对相同消息做出不同响应。
​ 当基类指针指向派生类对象时，编译器以为是基类对象，但因为是虚函数，所以编译器建立虚函数表并在对象中存放虚函数指针，导致运行时调用重写的虚函数。

​ 对于p->vfunc1()，因为p是基类指针，则编译器已经将所指派生类对象隐式转为基类对象，所以无法判定调用哪个函数

注意事项

• 不能把静态成员函数声明为虚函数，因为静态成员函数不属于某个对象，而虚函数是通过对象指针或引用来调用的
• 构造函数不能是虚函数，因为执行构造函数时，对象还没有实例化。但析构函数可以是虚函数，且有时是必须的

​ 针对第二点析构的，打个比方A *p = new B;，new了一个派生类对象，但是用的基类指针，也就是说最后调用了基类的析构，会导致派生类中新定义的成员无法销毁。因此析构函数也必须重写。

​ 每个类的析构函数负责销毁自己新定义的成员，派生类只需要销毁掉新定义的即可，至于继承来的成员，会调用基类的析构销毁。整个流程就是：基类指针调用析构（虚函数），派生类析构，由于继承关系，基类析构（这里和虚函数没关系，纯属是“继承”的特性）

​ 析构的虚函数有其特殊性，比如在基类和派生类中函数名不同，但就运行时多态而言，与其他虚函数性质一样。

​ 详细研究虚析构函数在虚函数表情况，参见：c++虚析构函数在虚函数表中吗?

纯虚函数和抽象类

纯虚函数是一个在基类中说明的虚函数，它在该基类中仅定义了函数首部，必须在派生类中重写

定义：virtual 返回类型 函数名(参数表)=0;

有纯虚函数的类称为抽象类，其无法被实例化，不能做函数参数、返回类型或转换类型，但抽象类指针、引用可以

5. 模板

分为函数模板和类模板，是实现代码重用机制的一种工具

5.1 函数模板与模板函数

使用函数模板时需要实例化，可以显式、隐式实例化

template <typename T>
void swap(T &a, T &b){...}

//隐式
int main(){
    int x=1,y=2;
    swap<int>(x,y);
    //或swap(x,y);
    ....
}

//显式
template
void swap(int &a,int &b);
int main(){
    int x=1,y=2;
    swap(x,y);
    ....
}

函数模板中没有隐式的类型转换（形参到实参），但是重载后的模板函数（也就成了普通函数）是可以隐式转换的

template <class T>
T max(T x, T y) {
    return (x > y) ? x : y;
}

void func(int i, char c) {
    max(i, i);  // 正确 调用max(int,int)
    max(c, c);  // 正确 调用max(char,char)
    max(i, c);  // 错误 类型不匹配
    max(c, i);  // 错误 类型不匹配
}

解决方法：

• 采用强制类型转换，如将上述max(i,c)；改写为max(i,int(c));

• 用非模板函数去重载函数模板

  char max(int x, char y) {
      return (x > y) ? x : y;
  }
  

  这样就会调用这个普通的重载函数

模板函数、函数重载的匹配次序

优先级为：

1. 参数完全匹配的（重载或实例化）函数
2. （隐式）实例化后能匹配的模板函数
3. 类型转换后能匹配上的重载函数

例如

template <class T>
T myMax(T x, T y) {  // 模板
    // ...
}

int myMax(int x, int y) {  // 重载1
    // ...
}

char myMax(int x, char y) {  // 重载2
    // ...
}


int main() {
    int i = 10;
    char c = ‘a’;
    float f = 43.74;
    cout << myMax(i, i) << endl;  // 重载1
    cout << myMax(c, c) << endl;  // 模板
    cout << myMax(i, c) << endl;  // 重载2
    cout << myMax(c, i) << endl;  // 重载2 （隐式转换）
    cout << myMax(f, f) << endl;  // 模板
    cout << myMax(f, i) << endl;  // 隐式转换是必须的，但是既可以转成重载1，又可以转成重载2
    							  // 此时选择哪一个由编译器决定，不同编译器可能有不同选择
    return 0;
}

5.2 类模板和模板类

dddd

6. 代码巩固

运算符重载

有一个String类，只有一个成员变量

class String {
    char* array;
}

1）重载[]

这里为了理解面向对象的一些点，采用了很奇怪的写法，仅仅保证语法无误

关注点：返回值应该是引用

char& operator[](int i) {
    if (i < 0 || i >= strlen(array)) {
        cout << "Index out of range." << endl;
        static char dummy = '\0';
        return dummy;
    }
    return array[i];
}

2）重载+

如果要做String + String的运算

这是一种返回临时对象的写法

String operator+(const String& s) {  // 形参中的const和引用都可省略，语法上没问题
    String temp(array);
    temp.array = new char[strlen(array) + strlen(s.array) + 1];
    strcpy(temp.array, array);
    strcat(temp.array, s.array);
    return temp;
}

如果要做String + char*的运算

• 一种方法是重载+运算符，接收一个char*类型的参数

• 一种方法是使用类型转换

  • 比如把char*转为String，用构造函数就可以实现，运算时编译器会自动隐式转换，从而转为String + String。

    需要注意的是，这种方法会把char*转为一个临时对象String，这个临时对象作为+函数参数传入时，函数形参必须声明为const。也就是说，运算符重载函数接收一个临时对象时，必须是const。

  • 若把String转为char*，则需要重载char*()

  但是这两种方法不能同时使用，即不能同时有char* -> String和 String -> char*，否则会有二义性：既可以转为char* + char*，又可以转为String + String

提供隐式类型转换

整个思路是：A重载了+运算符，但是只能和A相加，因此这里给B提供了一个转化为A的类型转换重载，编译器在计算a+b时，会自动把b隐式转换为a

class A {
    int a;
  public:
    A() { a = 0; }
    A(int i) { a = i; }
    int operator+(const A& aa) { return a + aa.a; }
};

class B {
    int b;
  public:
    B() { b = 0; }
    operator A() { return A(b); }
};

int main() {
    A a;
    B b;
    cout << a + b << endl;
    return 0;
}

输出运算符重载

如正文所讲，<<只能采用友元函数重载，并且返回值得是引用，第一个参数得是引用，第二个参数中如果要接收一个临时对象，必须用const修饰

friend ostream& operator<<(ostream& out, const String& s) {
    out << s.array;
    return out;
}

编译器的移动构造优化

class A {
    int x;
    
  public:
    A(int i = 0) {  // 构造
        x = i;
        cout << "construct";
    }
    A(const A& a) {  // 拷贝构造
        cout << "copy";
    }
    A operator+(const A& a) {  // 重载+
        cout << "add";
        return A(x + a.x);
    }
    void operator=(const A& a) {  // 重载=
        cout << "equals";
    }
};

int main() {
    A a, b;
    A c = a;
    A d = a + b;
    return 0;
}

这段代码最终输出为：con con copy add con

分析：

• A a, b; 两次默认构造
• A c = a; 标准的拷贝构造
• A d = a + b; 显然先有一次 + 重载，之后编译器会优化，效果等价于 A d(a + b); 也就是一次普通构造

怎么区分 = 是拷贝构造还是赋值运算呢？只有在初始化对象的时候，才会使用拷贝构造，如果对象已经被创建了，之后的=都是赋值

小综合

题目：

有四种几何图形：三角形、矩形、正方形和圆。
求四种几何图形的面积之和。

定义一个包含两个虚函数的类

class Shape {
  public:
    virtual float Area(void) = 0;                // 求面积
    virtual void SetData(float, float = 0) = 0;  // 设置几何形状参数
    											 // 不同集合形状需要1个或2个参数，故采用默认参数值

};

公有派生各类，重写两个函数，这里只展示一个类，其余同理。

class Triangle : public Shape {
    float W, H;  // 三角形边长为W，高为H
   public:
    Triangle(float w = 0, float h = 0) {
        W = w;
        H = h;
    }
    float Area(void) {  // 重写虚函数
        return W * H / 2;
    }
    void Setdata(float w, float h = 0) {  // 重写虚函数
        W = w;
        H = h;
    }
};

这里使用了一个指针数组，来实现多态；如果采用对象数组，则无法实现多态

class Compute {
    Shape** s;  // 指向基类的指针数组
  public:
    Compute() {  // 给几何图形设置参数
        s = new Shape*[4];
        s[0] = new Triangle(3, 4);
        s[1] = new Rectangle(6, 8);
        s[2] = new Square(6.5);
        s[3] = new Circle(5.5);
    }
    float SumArea(void);
    ~Compute();
    void Setdata(int n, float a, float b = 0) { s[n]->Setdata(a, b); }
};

float Compute::SumArea(void) {
    float sum = 0;
    for (int i = 0; i < 4; i++)
        sum += s[i]->Area();  // 通过基类指针实现多态性
    return sum;
}

Compute::~Compute() {
    for (int i = 0; i < 4; i++)
        delete s[i];
    delete[] s;
}