帮我利用c++的基类 (public、private、protected)包括（数据、函数成员、存动态数组） 、重载函数、构造函数、析构函数(消除动态数组）、静态数据、友元函数、继承、虚函数等知识点编写一个程序，并告诉我这个程序是用来做什么

首先，让我们创建一个简单的 C++ 程序示例，它演示了多个关键知识点：

#include <iostream>
using namespace std;

// 基类 - 存储动态数组
class Base {
public:
    int* dynamicArray; // 动态数组作为数据成员
    int size; // 数组大小

    // 构造函数，初始化动态数组
    Base(int capacity = 5) {
        dynamicArray = new int[capacity];
        size = 0;
    }

    // 析构函数，释放动态内存
    ~Base() {
        delete[] dynamicArray;
    }

    // 重载运算符，用于访问数组元素
    int get(int index) const {
        if (index >= 0 && index < size)
            return dynamicArray[index];
        else
            throw out_of_range("Index out of range");
    }

    // 虚函数，表示可以被子类覆盖
    virtual void display() {
        cout << "Base Class Array: ";
        for (int i = 0; i < size; ++i)
            cout << dynamicArray[i] << " ";
        cout << endl;
    }

    // 友元函数，允许非成员访问私有成员
    friend void printPrivate(Base& obj);
};

// 子类 - 继承基类并重写虚函数
class Derived : public Base {
private:
    // 静态数据
    static int count;

public:
    Derived(int capacity) : Base(capacity) {}

    // 重载构造函数
    Derived(int capacity, int value) : Base(capacity), addValue(value) {
        for (int i = 0; i < capacity; ++i)
            dynamicArray[i] = value;
    }

    // 新增函数成员
    int addValue;

    // 重写虚函数
    void display() override {
        cout << "Derived Class Array: ";
        for (int i = 0; i < size; ++i)
            cout << dynamicArray[i] + addValue << " ";
        cout << endl;
    }
};

// 友元函数实现
void printPrivate(Base& obj) {
    cout << "Private data in Base class: " << obj.size << endl;
}

int main() {
    Derived d1(5); // 创建子类对象
    d1.addValue = 10;
    d1.display(); // 调用子类的显示方法
    printPrivate(d1); // 友元函数访问私有数据

    Base* basePtr = &d1; // 指向子类的基类指针
    basePtr->display(); // 虚函数调用，显示子类的行为

    // 通过基类指针创建新实例
    Derived d2(4, 5);
    basePtr = &d2;
    basePtr->display(); // 显示新的值

    return 0;
}

这个程序的作用是展示以下几个概念：
1. 使用基类 `Base` 存储动态数组并管理内存；
2. 实现构造函数和析构函数，确保动态内存的正确分配和释放；
3. 重载运算符 `get()` 访问数组元素；
4. 定义虚函数 `display()`，允许子类重写其行为；
5. 创建子类 `Derived` 并重写虚函数；
6. 使用构造函数重载和继承的概念；
7. 展示友元函数 `printPrivate()` 的使用，允许访问私有数据；
8. 通过基类指针动态地切换到子类的行为。

相关问题：
1. 这段代码展示了哪些类型的继承（公有还是私有）？
2. 哪些部分体现了多态性？
3. 为什么需要友元函数以及它在这段代码中的作用是什么？