student类具体要求如下: 私有成员变量:学号(sid

)、姓名(name)、性别(gender)、年龄(age)、成绩(score)。

公有成员函数：

1.构造函数，可以根据参数初始化学号、姓名、性别、年龄和成绩；

2.析构函数；

3.获取学号的函数getSid()，返回学号；

4.获取姓名的函数getName()，返回姓名；

5.获取性别的函数getGender()，返回性别；

6.获取年龄的函数getAge()，返回年龄；

7.获取成绩的函数getScore()，返回成绩；

8.设置学号的函数setSid(int sid)，可以设置学号；

9.设置姓名的函数setName(string name)，可以设置姓名；

10.设置性别的函数setGender(string gender)，可以设置性别；

11.设置年龄的函数setAge(int age)，可以设置年龄；

12.设置成绩的函数setScore(double score)，可以设置成绩；

13.输出学生信息的函数display()，可以输出学号、姓名、性别、年龄和成绩。

注意：以上所有函数均需实现。

相关问题

学生类（Student）从人员类公有继承，成员包含： 私有成员变量，学号（id，string类型） 公有构造函数 公有函数display

好的，以下是一个可能的学生类的实现，它从人员类公有继承并添加了额外的成员变量和成员函数：

#include <iostream>
#include <string>

class Person {
protected:
    std::string name;
    int age;

public:
    Person(const std::string& name, int age) : name(name), age(age) {}

    void display() const {
        std::cout << "Name: " << name << std::endl;
        std::cout << "Age: " << age << std::endl;
    }
};

class Student : public Person {
private:
    std::string id;

public:
    Student(const std::string& name, int age, const std::string& id)
        : Person(name, age), id(id) {}

    void display() const {
        Person::display();
        std::cout << "Student ID: " << id << std::endl;
    }
};

这个类定义了一个 `Student` 类，它从 `Person` 类公有继承。它添加了一个私有成员变量 `id`，表示学生的学号。它还有一个公有的构造函数，用于初始化 `name`、`age` 和 `id`。最后，它还有一个公有的 `display` 函数，用于输出 `name`、`age` 和 `id` 的值。

请注意，我们在 `Student` 类中使用了 `Person::display()` 函数来调用基类 `Person` 的 `display` 函数，以确保基类的信息也能被输出。另外，我们在 `Student` 类中使用了 `public` 修饰符来继承 `Person` 类的公有成员，因此 `Student` 类的对象可以访问 `Person` 类的公有成员函数和保护成员变量。

希望这可以回答你的问题。

请设计人员和学生类，并通过测试程序，具体要求如下： 人员类（person）是基类，成员包含： 保护成员变量，姓名（name，string类型） 保护成员变量，年龄（age，int类型） 公有构造函数 公有函数display 学生类（student）从人员类公有继承，成员包含： 私有成员变量，学号（id，string类型） 公有构造函数 公有函数display

### 回答1：
人员类（Person）：

成员变量：
- 姓名（name，string类型，保护）
- 年龄（age，int类型，保护）

构造函数：
- 公有构造函数

成员函数：
- display()，公有函数，用于显示人员的姓名和年龄信息

学生类（Student）：

继承关系：
- 公有继承自人员类（Person）

成员变量：
- 学号（id，string类型，私有）

构造函数：
- 公有构造函数，用于初始化学号和人员信息

成员函数：
- display()，公有函数，用于显示学生的姓名、年龄和学号信息

测试程序：

#include <iostream>
#include <string>
using namespace std;

class Person {
protected:
string name;
int age;
public:
Person() {}
Person(string n, int a) : name(n), age(a) {}
void display() {
cout << "姓名：" << name << endl;
cout << "年龄：" << age << endl;
}
};

class Student : public Person {
private:
string id;
public:
Student() {}
Student(string n, int a, string i) : Person(n, a), id(i) {}
void display() {
Person::display();
cout << "学号：" << id << endl;
}
};

int main() {
Student s("张三", 18, "20210001");
s.display();
return ;
}

输出结果：
姓名：张三
年龄：18
学号：20210001

### 回答2：
人员类（person）可以定义如下：

class person {
protected:
    string name;
    int age;
public:
    person(string n, int a):name(n), age(a){}
    void display() {
        cout << "name: " << name << endl;
        cout << "age: " << age << endl;
    }
};

其中，保护成员变量姓名（name）和年龄（age）是通过构造函数赋初值。

学生类（student）可以定义如下：

class student : public person {
private:
    string id;
public:
    student(string n, int a, string i):person(n, a), id(i){}
    void display() {
        person::display();
        cout << "id: " << id << endl;
    }
};

其中，私有成员变量学号（id）是通过构造函数赋初值，并通过公有继承方式获得人员类的成员函数。

为了验证该程序是否正确，可以定义测试函数：

int main() {
    person p("tom", 20);
    p.display();
    cout << "------------------------------" << endl;
    student s("jerry", 18, "001");
    s.display();
    return 0;
}

输出结果为：

name: tom
age: 20
------------------------------
name: jerry
age: 18
id: 001

可以看到，人员类和学生类的成员变量和成员函数可以正确的输出，并且学生类通过继承方式正确继承了人员类的成员函数。

### 回答3：
人员类（person）是一个基类，包含两个保护成员变量：姓名（name，string类型）和年龄（age，int类型），以及一个公有构造函数。在基类中，我们可以创建一个display函数，用于显示人员的姓名和年龄。该函数可以在子类中被重写。

下面是人员类（person）的定义：

class person {
protected:
    string name;
    int age;

public:
    person(string name, int age) : name(name), age(age) {}

    virtual void display() {
        cout << "Name: " << name << endl;
        cout << "Age: " << age << endl;
    }
};

学生类（student）从人员类公有继承。除了继承自人员类的公有和保护成员，学生类还有一个私有成员变量：学号（id，string类型）。学生类有一个公有构造函数，并且可以重写基类的display函数来显示学生的信息。

下面是学生类（student）的定义：

class student : public person {
private:
    string id;

public:
    student(string name, int age, string id) : person(name, age), id(id) {}
    
    void display() {
        cout << "ID: " << id << endl;
        person::display();
    }
};

现在，我们可以编写一个测试程序，创建一些人员和学生对象，并使用display函数打印它们的信息。下面是测试程序的代码：

int main() {
    person p1("John", 30);
    student s1("Alice", 20, "123456");

    p1.display();
    cout << endl;
    s1.display();

    return 0;
}

程序的输出如下：

Name: John
Age: 30

ID: 123456
Name: Alice
Age: 20

我们可以看到，我们成功地创建了一个人员类（person）和一个学生类（student），并使用display函数打印了它们的信息。由于学生类重写了display函数，所以它打印了学生的ID以及从基类继承而来的姓名和年龄。