在主函数中，可以创建一个指向 Book 类的指针数组，然后动态地创建 Book 类的对象和 EBook 类的对象，将这些对象存储到指针数组中。然后，可以通过循环来调用每个对象的 print() 函数，实现多态输出。

是的，可以在主函数中创建一个指向 Book 类的指针数组，然后动态地创建 Book 类的对象和 EBook 类的对象。将这些对象存储在指针数组中，然后通过循环来调用每个对象的 print() 函数，实现多态输出。

例如：

Book* books[2];
books[0] = new Book;
books[1] = new EBook;

for (int i = 0; i < 2; i++) {
  books[i]->print();
}

在上面的代码中，我们创建了一个指向 Book 类的指针数组，然后动态地创建了两个对象：一个是 Book 类的对象，另一个是 EBook 类的对象。然后，我们通过循环来调用每个对象的 print() 函数，实现多态输出。

相关问题

用c++语言编写一个完整代码在主函数中，可以创建一个指向 Book 类的指针数组，然后动态地创建 Book 类的对象和 EBook 类的对象，将这些对象存储到指针数组中。

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

#define MAX_BOOKS 10

// Book 类的声明
class Book {
  public:
    Book(char* t, char* a, int p) {
      title = t;
      author = a;
      pages = p;
    }
    void setTitle(char* t) { title = t; }
    void setAuthor(char* a) { author = a; }
    void setPages(int p) { pages = p; }
    char* getTitle() { return title; }
    char* getAuthor() { return author; }
    int getPages() { return pages; }
  private:
    char* title;
    char* author;
    int pages;
};

// EBook 类的声明，继承于 Book 类
class EBook: public Book {
  public:
    EBook(char* t, char* a, int p, char* f):Book(t, a, p) {
      fileFormat = f;
    }
    void setFileFormat(char* f) { fileFormat = f; }
    char* getFileFormat() { return fileFormat; }
  private:
    char* fileFormat;
};

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

  // 动态地创建 Book 类的对象
  books[0] = new Book("《计算机科学概论》", "Alan", 792);
  books[1] = new Book("《红楼梦》", "曹雪芹", 1225);

  // 动态地创建 EBook 类的对象
  books[2] = new EBook("《钢铁是怎样炼成的》", "奥斯特洛夫斯基", 296, "PDF");
  books[3] = new EBook("《哈利·波特与被诅咒的孩子》", "J.K. 罗琳", 672, "EPUB");

  return 0;
}

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

以下是一个示例代码，它实现了创建一个指向 Book 类的指针数组，然后动态地创建 Book 类的对象和 EBook 类的对象，将这些对象存储到指针数组中，最后通过循环来调用每个对象的 print() 函数，实现多态输出。

#include <iostream>
#include <cstring>
#include <vector>

using namespace std;

// 定义 Book 类
class Book {
public:
  Book(const char* title, const char* author, int pageCount)
    : title(title), author(author), pageCount(pageCount) {}

  virtual void print() {
    cout << "Book: " << title << ", " << author << ", " << pageCount << " pages" << endl;
  }

protected:
  const char* title;
  const char* author;
  int pageCount;
};

// 定义 EBook 类，继承自 Book 类
class EBook : public Book {
public:
  EBook(const char* title, const char* author, int pageCount, const char* fileSize)
    : Book(title, author, pageCount), fileSize(fileSize) {}

  void print() override {
    cout << "EBook: " << title << ", " << author << ", " << pageCount << " pages, " << fileSize << endl;
  }

private:
  const char* fileSize;
};

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

  // 动态地创建 Book 类的对象和 EBook 类的对象，将这些对象存储到指针数组中
  books.push_back(new Book("C++ Primer", "Stanley B. Lippman", 1008));
  books.push_back(new EBook("JavaScript: The Definitive Guide", "David Flanagan", 1136, "5MB"));
  books.push_back(new EBook("Effective Python", "Brett Slatkin", 240, "2MB"));

  // 通过循环来调用每个对象的 print() 函数，实现多态输出
  for (Book* book : books) {
    book->print();
  }