编写C++程序，程序中需要体现类的多重继承、类的多级继承、虚继承、公共继承、保护继承、私有继承、子对象、类的组合、虚函数、纯虚函数等特性，须完整各类的构造函数、析构函数。

好的，我可以为您提供一份简单的示例程序，其中包含了类的多重继承、类的多级继承、虚继承、公共继承、保护继承、私有继承、子对象、类的组合、虚函数、纯虚函数等特性。请您参考以下代码：

#include <iostream>

using namespace std;

// 基类 A
class A {
public:
    A() { cout << "A's constructor called" << endl; }
    virtual ~A() { cout << "A's destructor called" << endl; }
    void print() { cout << "This is A" << endl; }
};

// 基类 B
class B {
public:
    B() { cout << "B's constructor called" << endl; }
    virtual ~B() { cout << "B's destructor called" << endl; }
    void print() { cout << "This is B" << endl; }
};

// 基类 C
class C {
public:
    C() { cout << "C's constructor called" << endl; }
    virtual ~C() { cout << "C's destructor called" << endl; }
    virtual void print() { cout << "This is C" << endl; }
};

// 基类 D
class D {
public:
    D() { cout << "D's constructor called" << endl; }
    virtual ~D() { cout << "D's destructor called" << endl; }
    virtual void print() = 0; // 纯虚函数
};

// 派生类 E 继承自 A、B
class E : public A, public B {
public:
    E() { cout << "E's constructor called" << endl; }
    ~E() { cout << "E's destructor called" << endl; }
};

// 派生类 F 继承自 E、C
class F : public E, public C {
public:
    F() { cout << "F's constructor called" << endl; }
    ~F() { cout << "F's destructor called" << endl; }
    void print() override { cout << "This is F" << endl; } // 覆盖基类 C 的虚函数
};

// 派生类 G 继承自 B，以虚继承方式继承自 C
class G : public virtual B, public virtual C {
public:
    G() { cout << "G's constructor called" << endl; }
    ~G() { cout << "G's destructor called" << endl; }
    void print() override { cout << "This is G" << endl; } // 覆盖基类 C 的虚函数
};

// 派生类 H 继承自 A，以保护继承方式继承自 D
class H : protected A, protected D {
public:
    H() { cout << "H's constructor called" << endl; }
    ~H() { cout << "H's destructor called" << endl; }
    void printA() { A::print(); } // 访问 A 的成员函数
    void printD() { D::print(); } // 访问 D 的成员函数
};

// 派生类 I 继承自 F，以私有继承方式继承自 G
class I : private F, private G {
public:
    I() { cout << "I's constructor called" << endl; }
    ~I() { cout << "I's destructor called" << endl; }
    void printF() { F::print(); } // 访问 F 的成员函数
    void printG() { G::print(); } // 访问 G 的成员函数
};

// 类 J 包含一个 C 的子对象
class J {
public:
    J() { cout << "J's constructor called" << endl; }
    ~J() { cout << "J's destructor called" << endl; }
private:
    C c;
};

// 类 K 组合了 A、B、C、D 四个类的对象
class K {
public:
    K() { cout << "K's constructor called" << endl; }
    ~K() { cout << "K's destructor called" << endl; }
private:
    A a;
    B b;
    C c;
    D* d;
};

int main() {
    // 演示类的多重继承
    cout << "----- Test for multiple inheritance -----" << endl;
    E e;
    e.A::print(); // 访问基类 A 的成员函数
    e.B::print(); // 访问基类 B 的成员函数

    // 演示类的多级继承
    cout << "----- Test for multilevel inheritance -----" << endl;
    F f;
    f.A::print(); // 访问基类 A 的成员函数
    f.B::print(); // 访问基类 B 的成员函数
    f.C::print(); // 访问基类 C 的成员函数
    f.print();    // 访问覆盖后的虚函数

    // 演示虚继承
    cout << "----- Test for virtual inheritance -----" << endl;
    G g;
    g.B::print(); // 访问基类 B 的成员函数
    g.C::print(); // 访问基类 C 的成员函数
    g.print();    // 访问覆盖后的虚函数

    // 演示保护继承
    cout << "----- Test for protected inheritance -----" << endl;
    H h;
    h.printA();   // 访问基类 A 的成员函数
    h.printD();   // 访问基类 D 的成员函数

    // 演示私有继承和成员访问控制
    cout << "----- Test for private inheritance and member access control -----" << endl;
    I i;
    // i.A::print(); // 错误：A 对 I 不可访问
    // i.B::print(); // 错误：B 对 I 不可访问
    // i.E::print(); // 错误：E 对 I 不可访问
    i.printF();    // 访问 F 的成员函数
    i.printG();    // 访问 G 的成员函数
    // i.C::print(); // 错误：C 对 I 不可访问
    // i.D::print(); // 错误：D 对 I 不可访问

    // 演示子对象和类的组合
    cout << "----- Test for sub-object and class composition -----" << endl;
    J j;
    K k;
    
    return 0;
}

上述程序中，基类 A、B、C、D 分别表示不同的类，其中 C 类中包含一个虚函数 print()，D 类中包含一个纯虚函数 print() = 0。派生类 E 继承自 A、B，派生类 F 继承自 E、C，派生类 G 继承自 B 以虚继承方式继承自 C，派生类 H 继承自 A 以保护继承方式继承自 D，派生类 I 继承自 F 以私有继承方式继承自 G。类 J 包含一个 C 的子对象，类 K 组合了 A、B、C、D 四个类的对象。

在程序中，我们演示了类的多重继承、类的多级继承、虚继承、公共继承、保护继承、私有继承、子对象、类的组合、虚函数、纯虚函数等特性，并在每个类的构造函数、析构函数中输出相应的信息，以方便观察对象的创建和销毁过程，同时还演示了不同的成员访问控制方式。