定义一个包含两个纯虚函数的基类定义两个分别表示矩形和圆形的派生类分别计算出矩形和圆形的面积和周长。

### 回答1：
首先，基类可以定义如下：

class Shape {
public:
  virtual double Area() = 0;
  virtual double Perimeter() = 0;
};

纯虚函数是指不包含函数体的虚函数。它只有声明，没有实现。通常，我们使用纯虚函数来定义接口，即为了规定派生类必须实现的函数。

然后，可以使用基类来定义矩形和圆形的派生类：

class Rectangle : public Shape {
public:
  Rectangle(double length, double width) : length_(length), width_(width) {}

  double Area() override {
    return length_ * width_;
  }

  double Perimeter() override {
    return 2 * (length_ + width_);
  }

private:
  double length_;
  double width_;
};

class Circle : public Shape {
public:
  Circle(double radius) : radius_(radius) {}

  double Area() override {
    return 3.14 * radius_ * radius_;
  }

  double Perimeter() override {
    return 2 * 3.14 * radius_;
  }

private:
  double radius_;
};

在这里，我们使用 `override` 关键字来声明派生类函数是覆盖基类纯虚函数的实现。

最后，我们可以使用派生类的对象来计算矩形或圆形的面积和周长：

Rectangle rect(10, 5);
Circle circle(2);

cout << "Rectangle area: " << rect.Area() << endl;
cout << "Rectangle perimeter: " << rect.Perimeter() << endl;

cout << "Circle area: " << circle.Area() << endl;
cout << "Circle perimeter: " << circle.Perimeter() << endl;

输出结果如下：

Rectangle area: 50
Rectangle perimeter: 30
Circle area: 12.56
Circle perimeter: 12.56

### 回答2：
基类的定义如下：

class Shape {
public:
    virtual float getArea() const = 0; // 纯虚函数，计算面积
    virtual float getPerimeter() const = 0; // 纯虚函数，计算周长
};

派生类Rectangle（矩形）的定义如下：

class Rectangle : public Shape {
private:
    float length;
    float width;

public:
    Rectangle(float l, float w) : length(l), width(w) {}

    float getArea() const override {
        return length * width;
    }

    float getPerimeter() const override {
        return 2 * (length + width);
    }
};

派生类Circle（圆形）的定义如下：

class Circle : public Shape {
private:
    float radius;

public:
    Circle(float r) : radius(r) {}

    float getArea() const override {
        return 3.14159 * radius * radius;
    }

    float getPerimeter() const override {
        return 2 * 3.14159 * radius;
    }
};

在派生类Rectangle中，我们利用构造函数接收矩形的长和宽，并且重写基类中的纯虚函数，计算出矩形的面积 `length * width` 和周长 `2 * (length + width)`。

在派生类Circle中，我们利用构造函数接收圆形的半径，并且重写基类中的纯虚函数，计算出圆形的面积 `3.14159 * radius * radius` 和周长 `2 * 3.14159 * radius`。

通过这样的设计，我们可以通过调用基类指针指向派生类对象，通过基类指针调用相应的虚函数，从而实现多态性，并且可以正确计算矩形和圆形的面积和周长。

### 回答3：
基类的定义可以如下所示：

class Shape {
public:
    virtual float getArea() const = 0;
    virtual float getPerimeter() const = 0;
};

矩形类的派生类定义如下：

class Rectangle : public Shape {
protected:
    float length;
    float width;
public:
    Rectangle(float l, float w) : length(l), width(w) {}

    float getArea() const override {
        return length * width;
    }

    float getPerimeter() const override {
        return 2 * (length + width);
    }
};

圆形类的派生类定义如下：

class Circle : public Shape {
protected:
    float radius;
public:
    Circle(float r) : radius(r) {}

    float getArea() const override {
        return 3.14 * radius * radius;
    }

    float getPerimeter() const override {
        return 2 * 3.14 * radius;
    }
};

这样，当你创建一个矩形或圆形对象时，可以通过调用`getArea()`方法计算出其面积，调用`getPerimeter()`方法计算出其周长。例如：

Rectangle rect(5, 3);  // 创建一个矩形对象，长度为5，宽度为3
cout << "矩形的面积：" << rect.getArea() << endl;  // 输出：15
cout << "矩形的周长：" << rect.getPerimeter() << endl;  // 输出：16

Circle circle(4);  // 创建一个圆形对象，半径为4
cout << "圆形的面积：" << circle.getArea() << endl;  // 输出：50.24
cout << "圆形的周长：" << circle.getPerimeter() << endl;  // 输出：25.12