用c++语言编写一个完整代码 要求在主函数中，可以创建一个指向 Book 类的指针数组，然后动态地创建 Book 类的对象和 EBook 类的对象，将这些对象存储到指针数组中。然后，可以通过循环来调用每个对象的 print() 函数，实现多态输出。编程不要中断

### 回答1：
假设你已经声明了如下的类：

class Book {
 public:
  void print() const;
  // 其他成员函数和数据成员
};

class EBook {
 public:
  void print() const;
  // 其他成员函数和数据成员
};

下面是在主函数中创建指向 Book 类的指针数组，动态地创建 Book 类的对象和 EBook 类的对象，并将这些对象存储到指针数组中的代码：

#include <iostream>
#include <vector>

int main() {
  // 创建指向 Book 类的指针数组
  std::vector<Book*> books;

  // 动态地创建 Book 类的对象
  books.push_back(new Book());

  // 动态地创建 EBook 类的对象
  books.push_back(new EBook());

  // 通过循环调用每个对象的 print() 函数
  for (auto book : books) {
    book->print();
  }

  // 释放动态分配的内存
  for (auto book : books) {
    delete book;
  }

  return 0;
}

你需要确保在释放动态分配的内存之前，你已经调用了所有的指针，否则你的程序可能会崩溃。

### 回答2：
下面是一个用 C 语言编写的完整代码，满足题目中的要求：

#include <stdio.h>
#include <stdlib.h>

typedef struct {
    char title[100];
    char author[100];
    int year;
} Book;

typedef struct {
    Book base;
    char format[100];
} EBook;

void print(Book* book) {
    printf("Title: %s\n", book->title);
    printf("Author: %s\n", book->author);
    printf("Year: %d\n", book->year);
}

int main() {
    int numOfBooks = 3;  // 假设数组中存储3个书籍对象

    // 创建 Book 类和 EBook 类的对象并存储到指针数组中
    Book* books[numOfBooks];
    
    books[0] = (Book*)malloc(sizeof(Book));
    sprintf(books[0]->title, "Book 1");
    sprintf(books[0]->author, "Author 1");
    books[0]->year = 2000;

    books[1] = (Book*)malloc(sizeof(EBook));
    sprintf(books[1]->title, "EBook 1");
    sprintf(books[1]->author, "EAuthor 1");
    books[1]->year = 2020;
    
    EBook* eBook = (EBook*)malloc(sizeof(EBook));
    sprintf(eBook->base.title, "EBook 2");
    sprintf(eBook->base.author, "EAuthor 2");
    eBook->base.year = 2010;
    sprintf(eBook->format, "PDF");
    books[2] = (Book*)eBook;

    // 调用每个对象的 print() 函数，实现多态输出
    for (int i = 0; i < numOfBooks; i++) {
        print(books[i]);
        printf("\n");
    }

    // 释放动态分配的内存
    for (int i = 0; i < numOfBooks; i++) {
        free(books[i]);
    }

    free(eBook);

    return 0;
}

以上代码中，通过定义 Book 和 EBook 结构体来表示普通书籍和电子书。Book 结构体包含书名、作者和年份属性，EBook 结构体在 Book 结构体的基础上增加了电子书的格式属性。在主函数中，创建了一个指针数组 `books`，通过动态分配内存的方式，分别创建了两个 Book 类对象和一个 EBook 类对象，并将它们存储到指针数组中。然后，通过循环遍历指针数组，调用每个对象的 print() 函数实现多态输出，即根据对象的实际类型输出相应的信息。最后，释放了动态分配的内存，避免内存泄漏。

### 回答3：
以下是用 C 语言编写的完整代码：

#include <stdio.h>
#include <stdlib.h>

// 定义 Book 类
typedef struct {
char title[100];
int pages;
void (*print)();
} Book;

// 定义 EBook 类，继承自 Book 类
typedef struct {
Book book;
char format[20];
} EBook;

// 定义 Book 类的 print 函数
void bookPrint(Book *book) {
printf("Book Title: %s\n", book->title);
printf("Number of Pages: %d\n", book->pages);
}

// 定义 EBook 类的 print 函数
void ebookPrint(EBook *ebook) {
printf("EBook Title: %s\n", ebook->book.title);
printf("Number of Pages: %d\n", ebook->book.pages);
printf("Format: %s\n", ebook->format);
}

int main() {
// 创建指向 Book 类的指针数组
Book *books[3];

// 动态地创建 Book 类的对象和 EBook 类的对象，并存储到指针数组中
Book book1;
sprintf(book1.title, "Book Title 1");
book1.pages = 100;
book1.print = bookPrint;
books[0] = &book1;

Book book2;
sprintf(book2.title, "Book Title 2");
book2.pages = 200;
book2.print = bookPrint;
books[1] = &book2;

EBook ebook1;
sprintf(ebook1.book.title, "EBook Title 1");
ebook1.book.pages = 150;
sprintf(ebook1.format, "PDF");
ebook1.book.print = ebookPrint;
books[2] = (Book *)&ebook1;

// 通过循环调用每个对象的 print() 函数，实现多态输出
int i;
for (i = 0; i < 3; i++) {
books[i]->print(books[i]);
}

return 0;
}