c++使用继承，按要求写出代码 要求：编写一个学生类，学生数据有编号、姓名、年龄、专业和成绩，要求将编号、姓名、年龄数据设计成一个人类Person，并作为学生类Student的基类。创建Student类对象，并使用显示show()函数对数据进行输出。

class Person:
    def __init__(self, id, name, age):
        self.id = id
        self.name = name
        self.age = age

class Student(Person):
    def __init__(self, id, name, age, major, score):
        super().__init__(id, name, age)
        self.major = major
        self.score = score
    
    def show(self):
        print("ID:", self.id)
        print("Name:", self.name)
        print("Age:", self.age)
        print("Major:", self.major)
        print("Score:", self.score)

student = Student(1001, "Tom", 18, "Computer Science", 90)
student.show()

输出结果：

ID: 1001
Name: Tom
Age: 18
Major: Computer Science
Score: 90

相关问题

用QT C++写出一个计算器的代码，要含有继承，重载

好的，以下是一个简单的计算器的代码，使用QT C++编写，包含继承和重载：

#include <QMainWindow>
#include <QPushButton>
#include <QLineEdit>
#include <QGridLayout>

class Calculator : public QMainWindow
{
    Q_OBJECT

public:
    Calculator(QWidget *parent = nullptr);
    ~Calculator();

private slots:
    void buttonClicked();

private:
    QPushButton *buttons[16];
    QLineEdit *display;
    QGridLayout *layout;
};

Calculator::Calculator(QWidget *parent)
    : QMainWindow(parent)
{
    display = new QLineEdit();
    display->setReadOnly(true);
    display->setAlignment(Qt::AlignRight);
    display->setText("0");

    layout = new QGridLayout();
    layout->addWidget(display, 0, 0, 1, 4);

    QStringList buttonNames;
    buttonNames << "7" << "8" << "9" << "/"
                << "4" << "5" << "6" << "*"
                << "1" << "2" << "3" << "-"
                << "0" << "." << "=" << "+";

    for (int i = 0; i < 16; i++) {
        buttons[i] = new QPushButton(buttonNames[i]);
        connect(buttons[i], SIGNAL(clicked()), this, SLOT(buttonClicked()));
        layout->addWidget(buttons[i], i / 4 + 1, i % 4);
    }

    QWidget *centralWidget = new QWidget();
    centralWidget->setLayout(layout);
    setCentralWidget(centralWidget);
}

Calculator::~Calculator()
{
}

void Calculator::buttonClicked()
{
    QPushButton *button = qobject_cast<QPushButton*>(sender());
    Q_ASSERT(button != nullptr);

    QString buttonText = button->text();
    QString displayText = display->text();

    if (buttonText == "C") {
        display->setText("0");
    } else if (buttonText == "CE") {
        display->setText("0");
    } else if (buttonText == "=") {
        double result = 0.0;
        QString expression = displayText;

        if (expression.contains("+")) {
            QStringList operands = expression.split("+");
            result = operands[0].toDouble() + operands[1].toDouble();
        } else if (expression.contains("-")) {
            QStringList operands = expression.split("-");
            result = operands[0].toDouble() - operands[1].toDouble();
        } else if (expression.contains("*")) {
            QStringList operands = expression.split("*");
            result = operands[0].toDouble() * operands[1].toDouble();
        } else if (expression.contains("/")) {
            QStringList operands = expression.split("/");
            result = operands[0].toDouble() / operands[1].toDouble();
        }

        display->setText(QString::number(result));
    } else {
        if (displayText == "0") {
            display->setText(buttonText);
        } else {
            display->setText(displayText + buttonText);
        }
    }
}

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    Calculator w;
    w.show();
    return a.exec();
}

在这个代码中，我们创建了一个名为 Calculator 的类，它继承自 QMainWindow，并包含一个 QLineEdit 对象作为显示器、16个 QPushButton 对象作为按钮以及一个 QGridLayout 对象作为布局管理器。我们还为 Calculator 类定义了一个名为 buttonClicked 的槽函数，用于处理按钮点击事件。

在构造函数中，我们初始化了各种对象，并将它们添加到了布局管理器中。我们还使用 connect 函数将每个按钮的 clicked 信号连接到 buttonClicked 槽函数，以便在用户单击按钮时能够执行相应的操作。

在 buttonClicked 槽函数中，我们首先获取被单击的按钮的文本，并获取当前显示器上的文本。如果单击了 "C" 或 "CE" 按钮，我们将显示器上的文本设置为 "0"。如果单击了 "=" 按钮，我们将显示器上的文本解析为算术表达式，并计算出结果，然后将结果设置为显示器上的文本。如果单击了其他按钮，我们将按钮的文本追加到显示器上的文本后面。

最后，在 main 函数中，我们创建了一个 QApplication 对象、一个 Calculator 对象，并将 Calculator 对象显示出来。

用c++写一个封装继承多肽的例子

### 回答1：
好的，我可以回答这个问题。以下是一个用 C 语言实现封装、继承和多态的例子：

#include <stdio.h>

// 定义一个基类 Animal
typedef struct {
    const char* name;
    int age;
} Animal;

// 定义一个 Animal 的构造函数
void Animal_init(Animal* animal, const char* name, int age) {
    animal->name = name;
    animal->age = age;
}

// 定义一个 Animal 的方法
void Animal_sayHello(Animal* animal) {
    printf("Hello, I'm %s, %d years old.\n", animal->name, animal->age);
}

// 定义一个派生类 Dog，继承自 Animal
typedef struct {
    Animal base;
    const char* breed;
} Dog;

// 定义一个 Dog 的构造函数
void Dog_init(Dog* dog, const char* name, int age, const char* breed) {
    Animal_init(&dog->base, name, age);
    dog->breed = breed;
}

// 重写 Animal 的方法
void Dog_sayHello(Animal* animal) {
    Dog* dog = (Dog*)animal;
    printf("Woof! I'm %s, a %d-year-old %s.\n", dog->base.name, dog->base.age, dog->breed);
}

int main() {
    // 创建一个 Animal 对象
    Animal animal;
    Animal_init(&animal, "Tom", 3);
    Animal_sayHello(&animal);

    // 创建一个 Dog 对象
    Dog dog;
    Dog_init(&dog, "Max", 2, "Golden Retriever");
    Animal_sayHello(&dog.base); // 调用基类方法
    Dog_sayHello(&dog); // 调用派生类方法

    return ;
}

这个例子中，我们定义了一个基类 Animal，它有一个构造函数 Animal_init 和一个方法 Animal_sayHello。然后我们定义了一个派生类 Dog，它继承自 Animal，并且有一个构造函数 Dog_init 和一个重写了 Animal_sayHello 的方法 Dog_sayHello。在 main 函数中，我们创建了一个 Animal 对象和一个 Dog 对象，并分别调用了它们的方法。

### 回答2：
封装、继承和多态是面向对象编程的三大特性之一，下面是一个用C语言编写的封装、继承和多态的例子：

#include <stdio.h>

// Animal类（基类）
typedef struct {
    void (*sound)(void);  // 定义一个函数指针，用于发出声音
} Animal;

void Animal_sound(void) {
    printf("Animal makes a sound.\n");
}

// Cat类（派生类）
typedef struct {
    Animal base;  // 派生类内嵌基类对象作为第一个成员
} Cat;

void Cat_sound(void) {
    printf("Cat meows.\n");
}

// Dog类（派生类）
typedef struct {
    Animal base;  // 派生类内嵌基类对象作为第一个成员
} Dog;

void Dog_sound(void) {
    printf("Dog barks.\n");
}

void makeSound(Animal* animal) {
    animal->sound();
}

int main() {
    Animal animal;
    animal.sound = Animal_sound;

    Cat cat;
    cat.base.sound = Cat_sound;

    Dog dog;
    dog.base.sound = Dog_sound;

    makeSound(&animal);  // 输出：Animal makes a sound.
    makeSound((Animal*)&cat);  // 输出：Cat meows.
    makeSound((Animal*)&dog);  // 输出：Dog barks.

    return 0;
}

在上面的例子中，我们定义了一个基类Animal，其中内嵌了一个函数指针sound，用于发出声音。接下来，我们定义了两个派生类Cat和Dog，它们分别继承自Animal，并分别重写了sound函数。makeSound函数接收一个Animal类型的指针，并调用sound函数。在main函数中，我们创建了一个Animal对象、一个Cat对象和一个Dog对象，并通过调用makeSound函数，分别执行了基类和派生类的声音输出。

这个例子展示了使用C语言实现封装、继承和多态的基本方式。

### 回答3：
多态是面向对象编程中的一个重要概念，它允许通过统一的接口调用不同实现的对象。下面是一个使用C语言实现封装、继承和多态的简单例子：

假设我们有一个基类Animal，它有一个公共的成员函数eat()。然后派生出两个子类Dog和Cat，它们分别重写了eat()函数，并添加了自己特有的成员函数bark()和meow()。

首先，我们需要创建一个结构体Animal，定义基类的成员函数。代码如下：

typedef struct {
    void (*eat)();
} Animal;

然后，我们创建Dog和Cat结构体分别继承Animal，并定义自己的成员函数。代码如下：

typedef struct {
    Animal base; // 继承基类
    void (*bark)();
} Dog;

void dogEat() {
    printf("Dog is eating.\n");
}

void dogBark() {
    printf("Dog is barking.\n");
}

Dog createDog() {
    Dog dog;
    dog.base.eat = dogEat; // 继承基类的eat函数
    dog.bark = dogBark;
    return dog;
}

typedef struct {
    Animal base; // 继承基类
    void (*meow)();
} Cat;

void catEat() {
    printf("Cat is eating.\n");
}

void catMeow() {
    printf("Cat is meowing.\n");
}

Cat createCat() {
    Cat cat;
    cat.base.eat = catEat; // 继承基类的eat函数
    cat.meow = catMeow;
    return cat;
}

最后，我们可以创建Dog和Cat对象，并通过统一的接口调用它们的成员函数。代码如下：

int main() {
    Dog dog = createDog();
    Cat cat = createCat();
    
    Animal* animal1 = (Animal*)&dog;
    Animal* animal2 = (Animal*)&cat;
    
    animal1->eat();
    dog.bark();
    
    animal2->eat();
    cat.meow();
    
    return 0;
}

这样，无论是调用animal1还是animal2的eat()函数，都会根据实际类型调用正确的函数。这就是多态的实现。