C#定义一个人员类Cperson

在C#中，你可以定义一个名为`Person`的基本类来表示一个人，包括常见的属性如姓名、年龄等。下面是一个简单的例子：

public class Person
{
    // 定义基本属性
    public string Name { get; set; } // 姓名
    public int Age { get; set; } // 年龄

    // 构造函数，用于初始化对象
    public Person(string name, int age)
    {
        Name = name;
        Age = age;
    }

    // 普通成员方法，例如打招呼
    public void Greet()
    {
        Console.WriteLine("你好，我的名字是" + Name);
    }
}

在这个类中，我们定义了两个公共属性`Name`和`Age`，以及一个构造函数用于设置初始值。还定义了一个成员方法`Greet()`，当实例化这个`Person`对象并调用`Greet()`方法时，会打印出问候语。

相关问题

用c#定义一个人员类CPerson，包括数据成员：姓名、编号、性别和用于输入/输出的成员函数。在此基础上派生出学生类CStudent（增加成绩）和教师类CTeacher（增加教龄），并实现对学生和教师信息的输入/输出

在 C# 中，首先我们定义一个基础的人员类 `CPerson`：

public class CPerson
{
    // 数据成员
    public string Name { get; set; }
    public int ID { get; set; }
    public char Gender { get; set; }

    // 构造函数
    public CPerson(string name, int id, char gender)
    {
        Name = name;
        ID = id;
        Gender = gender;
    }

    // 输入函数（示例，这里通常会使用控制台输入或GUI组件）
    public void InputInfo()
    {
        Console.Write("请输入姓名：");
        Name = Console.ReadLine();
        Console.Write("请输入编号：");
        ID = int.Parse(Console.ReadLine());
        Console.Write("请输入性别（M/F）：");
        Gender = Console.ReadKey().KeyChar;
    }

    // 输出函数
    public void OutputInfo()
    {
        Console.WriteLine($"姓名：{Name}");
        Console.WriteLine($"编号：{ID}");
        Console.WriteLine($"性别：{Gender}");
    }
}

接下来，我们将派生两个子类 `CStudent` 和 `CTeacher`：

public class CStudent : CPerson
{
    // 子类特有的数据成员
    public double GPA { get; set; }

    // CStudent的构造函数
    public CStudent(string name, int id, char gender, double gpa) : base(name, id, gender)
    {
        GPA = gpa;
    }

    // 学生的输入/输出函数
    public void InputStudentInfo()
    {
        Console.Write("请输入GPA：");
        GPA = double.Parse(Console.ReadLine());
        base.InputInfo(); // 调用父类的输入函数
    }

    public void OutputStudentInfo()
    {
        base.OutputInfo();
        Console.WriteLine($"GPA：{GPA}");
    }
}

public class CTeacher : CPerson
{
    // 子类特有的数据成员
    public int TeachingYears { get; set; }

    // CTeacher的构造函数
    public CTeacher(string name, int id, char gender, int teachingYears) : base(name, id, gender)
    {
        TeachingYears = teachingYears;
    }

    // 教师的输入/输出函数
    public void InputTeacherInfo()
    {
        Console.Write("请输入教龄：");
        TeachingYears = int.Parse(Console.ReadLine());
        base.InputInfo(); // 调用父类的输入函数
    }

    public void OutputTeacherInfo()
    {
        base.OutputInfo();
        Console.WriteLine($"教龄：{TeachingYears}年");
    }
}

现在你可以使用这两个类来存储和显示学生的和教师的信息：

public static void Main()
{
    CStudent student = new CStudent("小明", 1234, 'M', 3.5);
    student.InputStudentInfo();
    student.OutputStudentInfo();

    CTeacher teacher = new CTeacher("李老师", 5678, 'F', 10);
    teacher.InputTeacherInfo();
    teacher.OutputTeacherInfo();
}

定义一个人员CPerson类，包含数据成员年龄和姓名，定义一个CPerson类的派生类教师CTeacher类，包含数据成员专业和职称。分别为两个类定义带参数的构造函数初始化，再分别定义display（）函数输出信息。将display()函数定义为虚函数，并用CPerson类的指针分别指向CPerson类和CTeacher类的对象，实现多态。编写主函数测试。

好的，我来为你解答这个问题。

首先，我们需要定义一个基类 `CPerson`，其中包含 `age` 和 `name` 两个数据成员。同时，我们需要定义一个带参数的构造函数来初始化这两个数据成员。

class CPerson {
public:
    CPerson(int age, std::string name) : age(age), name(name) {}

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

protected:
    int age;
    std::string name;
};

接下来，我们定义一个 `CTeacher` 类，它是 `CPerson` 的派生类。除了继承 `CPerson` 的数据成员外，它还包含了 `major` 和 `title` 两个数据成员。同样，我们需要定义一个带参数的构造函数来初始化这两个数据成员。

class CTeacher : public CPerson {
public:
    CTeacher(int age, std::string name, std::string major, std::string title)
            : CPerson(age, name), major(major), title(title) {}

    void display() override {
        std::cout << "Age: " << age << ", Name: " << name
                  << ", Major: " << major << ", Title: " << title << std::endl;
    }

private:
    std::string major;
    std::string title;
};

注意，我们将 `CPerson` 中的 `display()` 函数定义为了虚函数，并在 `CTeacher` 中进行了重写。

最后，我们在主函数中创建一个 `CPerson` 类的对象和一个 `CTeacher` 类的对象，并用 `CPerson` 类的指针分别指向它们，并分别调用 `display()` 函数，实现多态。

int main() {
    CPerson person(20, "Tom");
    CTeacher teacher(30, "Jack", "Computer Science", "Professor");

    CPerson* p1 = &person;
    CPerson* p2 = &teacher;

    p1->display();
    p2->display();

    return 0;
}

输出结果为：

Age: 20, Name: Tom
Age: 30, Name: Jack, Major: Computer Science, Title: Professor

这就完成了我们的需求，同时也实现了多态的效果。