假定“生物医学工程”和“生物工程”两个专业的学生分别上以下课程：
(1) 生物医学工程：数学、英语、物理、电子、机械
(2) 生物工程： 数学、英语、物理、分子、生化
假定“生物医学工程”班有4名学生，“生物工程”班有5名学生，分别计算并输出两个班级各门课程的平均分、最高分、最低分、……。
要求：
采用派生关系建立以下类：abstractClass(抽象类)类、BMEclass(生物医学工程班)类和BEclass(生物工程班)类：
(1) 对数据而言，
•class类：包含两个班级的共同课程；
•BMEclass类和Beclass类：分别包含各自的课程；
(2) 对数据(成绩)的处理函数(含输入输出)，请放置在合适的类中。
抽象类包含了他们的公共课程，包含输入和输出，
而各个子类BEclass和BMEclass来实现他们各自的独有的课程，以及输入输出方法，代码如下：
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
// 抽象类 AbstractClass
class abstractClass {
protected://公共课程
vector<float> mathScore_;
vector<float> englishScore_;
vector<float> physicsScore_;
public:
virtual void input() = 0;
virtual void output() = 0;
static float avg(vector<float>& score) {
float ret = 0.0f;
if (score.empty()) {
return 0.0f;
}
for (auto it = score.begin(); it != score.end(); it++) {
ret += *it;
}
return ret / score.size();
}
static float max(vector<float>& score) {
auto it = std::max_element(score.begin(), score.end());
if (it != score.end()) {
return *it;
}
return 0;
}
static float min(vector<float>& score) {
auto it = std::min_element(score.begin(), score.end());
if (it != score.end()) {
return *it;
}
return 0;
}
};
// 生物医学工程班
class BMEclass : public abstractClass {
protected: //电子、机械
vector<float> electronicsScore_;
vector<float> mechanicsScore_;
public:
virtual void input(){
float score = 0.0f;
int count = 0;
cout << "输入学生个数:" << endl;
cin >> count;
while (count > 0) {
cout << "输入学生的各科成绩:" << endl;
cout << "输入学生的数学成绩:";
cin >> score;
mathScore_.push_back(score);
cout << "输入学生的英语成绩:";
cin >> score;
englishScore_.push_back(score);
cout << "输入学生的物理成绩:";
cin >> score;
physicsScore_.push_back(score);
cout << "输入学生的电子成绩:";
cin >> score;
electronicsScore_.push_back(score);
cout << "输入学生的机械成绩:";
cin >> score;
mechanicsScore_.push_back(score);
--count;
}
}
virtual void output() {
cout << "课程: 平均分 最高分 最低分" << endl;
cout << "数学 " <<avg(mathScore_) << ", " << max(mathScore_) << ", " << min(mathScore_) << endl;
cout << "英语 " << avg(englishScore_) << ", " << max(englishScore_) << ", " << min(englishScore_) << endl;
cout << "物理 " << avg(physicsScore_) << ", " << max(physicsScore_) << ", " << min(physicsScore_) << endl;
cout << "电子 " << avg(electronicsScore_) << ", " << max(electronicsScore_) << ", " << min(electronicsScore_) << endl;
cout << "机械 " << avg(mechanicsScore_) << ", " << max(mechanicsScore_) << ", " << min(mechanicsScore_) << endl;
}
};
// 生物工程班
class BEclass : public abstractClass {
protected: //分子、生化
vector<float> molecularScore_;
vector<float> biochemistryScore_;
public:
virtual void input() {
float score = 0.0f;
int count = 0;
cout << "输入学生个数:" << endl;
cin >> count;
while (count > 0) {
cout << "输入学生的各科成绩:" << endl;
cout << "输入学生的数学成绩:";
cin >> score;
mathScore_.push_back(score);
cout << "输入学生的英语成绩:";
cin >> score;
englishScore_.push_back(score);
cout << "输入学生的物理成绩:";
cin >> score;
physicsScore_.push_back(score);
cout << "输入学生的分子成绩:";
cin >> score;
molecularScore_.push_back(score);
cout << "输入学生的生化成绩:";
cin >> score;
biochemistryScore_.push_back(score);
--count;
}
}
virtual void output() {
cout << "课程: 平均分 最高分 最低分" << endl;
cout << "数学 " << avg(mathScore_) << ", " << max(mathScore_) << ", " << min(mathScore_) << endl;
cout << "英语 " << avg(englishScore_) << ", " << max(englishScore_) << ", " << min(englishScore_) << endl;
cout << "物理 " << avg(physicsScore_) << ", " << max(physicsScore_) << ", " << min(physicsScore_) << endl;
cout << "分子 " << avg(molecularScore_) << ", " << max(molecularScore_) << ", " << min(molecularScore_) << endl;
cout << "生化 " << avg(biochemistryScore_) << ", " << max(biochemistryScore_) << ", " << min(biochemistryScore_) << endl;
}
};
int main() {
abstractClass* b1 = new BMEclass();
b1->input();
b1->output();
abstractClass* b2 = new BEclass();
b1->input();
b2->output();
delete b1;
delete b2;
return 0;
}
答案参考ChatGPT Plus版，整理汇总。希望能帮助你解决问题
根据题目要求，可以采用派生关系建立抽象类AbstractClass，以及BMEClass（生物医学工程班）和BEClass（生物工程班）两个派生类。以下是一个示例实现：
#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>
// 抽象类：共同课程
class AbstractClass {
protected:
std::vector<double> scores; // 成绩
public:
virtual void inputScores() = 0; // 输入成绩
virtual void outputScores() = 0; // 输出成绩
virtual double getAverageScore() = 0; // 平均分
virtual double getHighestScore() = 0; // 最高分
virtual double getLowestScore() = 0; // 最低分
};
// 生物医学工程班
class BMEClass : public AbstractClass {
public:
void inputScores() override {
std::cout << "Enter scores for BME class: " << std::endl;
double score;
for (int i = 0; i < 4; ++i) {
std::cin >> score;
scores.push_back(score);
}
}
void outputScores() override {
std::cout << "Scores for BME class: ";
for (double score : scores) {
std::cout << score << " ";
}
std::cout << std::endl;
}
double getAverageScore() override {
double sum = std::accumulate(scores.begin(), scores.end(), 0.0);
return sum / scores.size();
}
double getHighestScore() override {
return *std::max_element(scores.begin(), scores.end());
}
double getLowestScore() override {
return *std::min_element(scores.begin(), scores.end());
}
};
// 生物工程班
class BEClass : public AbstractClass {
public:
void inputScores() override {
std::cout << "Enter scores for BE class: " << std::endl;
double score;
for (int i = 0; i < 5; ++i) {
std::cin >> score;
scores.push_back(score);
}
}
void outputScores() override {
std::cout << "Scores for BE class: ";
for (double score : scores) {
std::cout << score << " ";
}
std::cout << std::endl;
}
double getAverageScore() override {
double sum = std::accumulate(scores.begin(), scores.end(), 0.0);
return sum / scores.size();
}
double getHighestScore() override {
return *std::max_element(scores.begin(), scores.end());
}
double getLowestScore() override {
return *std::min_element(scores.begin(), scores.end());
}
};
int main() {
BMEClass bmeClass;
BEClass beClass;
// 输入成绩
bmeClass.inputScores();
beClass.inputScores();
// 输出成绩
bmeClass.outputScores();
beClass.outputScores();
// 计算并输出平均分、最高分、最低分
std::cout << "Average score for BME class: " << bmeClass.getAverageScore() << std::endl;
std::cout << "Highest score
for BME class: " << bmeClass.getHighestScore() << std::endl;
std::cout << "Lowest score for BME class: " << bmeClass.getLowestScore() << std::endl;
std::cout << "Average score for BE class: " << beClass.getAverageScore() << std::endl;
std::cout << "Highest score for BE class: " << beClass.getHighestScore() << std::endl;
std::cout << "Lowest score for BE class: " << beClass.getLowestScore() << std::endl;
return 0;
}
在上述代码中，抽象类AbstractClass定义了成绩相关的纯虚函数，派生类BMEClass和BEClass分别实现了这些函数。通过在派生类中重写这些函数，可以根据具体的班级进行成绩的输入、输出和计算。
请注意，以上代码仅是一个示例，你可以根据实际需求进行适当修改和调整。
面向对象那一章应该有示例。可以结合那个写写看
根据题目要求，我们可以分别建立以下类：
(1) 抽象类 AbstractClass，包含所有课程成绩的数据和处理函数的框架：
java
Copy
public abstract class AbstractClass {
protected double mathScore;
protected double englishScore;
protected double physicsScore;
public abstract void inputScores();
public abstract void outputScores();
public abstract double getAverageScore();
public abstract double getHighestScore();
public abstract double getLowestScore();
}
(2) 生物医学工程班 BMEClass，继承自抽象类 AbstractClass，包含自己的课程成绩和处理函数：
java
Copy
public class BMEClass extends AbstractClass {
private double electronicScore;
private double mechanicalScore;
@Override
public void inputScores() {
// 输入各门课程的成绩
}
@Override
public void outputScores() {
// 输出各门课程的成绩和平均分、最高分、最低分等统计信息
}
@Override
public double getAverageScore() {
// 计算平均分
}
@Override
public double getHighestScore() {
//计算最高分
}
@Override
public double getLowestScore() {
// 计算最低分
}
}
(3) 生物工程班 BEClass，同样继承自抽象类 AbstractClass，包含自己的课程成绩和处理函数：
java
Copy
public class BEClass extends AbstractClass {
private double molecularScore;
private double biochemistryScore;
@Override
public void inputScores() {
// 输入各门课程的成绩
}
@Override
public void outputScores() {
// 输出各门课程的成绩和平均分、最高分、最低分等统计信息
}
@Override
public double getAverageScore() {
// 计算平均分
}
@Override
public double getHighestScore() {
// 计算最高分
}
@Override
public double getLowestScore() {
// 计算最低分
}
}
在这些类中，我们定义了各门课程的成绩变量，并实现了输入、输出、平均分、最高分和最低分等处理函数，具体实现可以根据具体情况进行编写。需要注意的是，AbstractClass类中的成绩变量需要被子类继承和使用，因此需要声明为 protected 类型。
在实际使用时，我们可以定义一个 Main 类来创建两个班级对象，然后调用各自的处理函数来计算和输出各门课程的成绩和统计信息。例如：
java
Copy
public class Main {
public static void main(String[] args) {
BMEClass bmeClass = new BMEClass();
BEClass beClass = new BEClass();
bmeClass.inputScores();
bmeClass.outputScores();
beClass.inputScores();
beClass.outputScores();
}
}
在这个示例中，我们创建了一个 Main 类，并在其中定义了一个 main 函数。在 main 函数中，我们先创建了一个生物医学工程班对象 bmeClass 和一个生物工程班对象 beClass，然后分别调用它们的输入和输出函数来计算和输出各门课程的成绩和统计信息。
需要注意的是，输入函数和输出函数的具体实现需要根据题目要求进行编写，这里只是给出一个大体的框架，具体的实现需要根据题目要求进行编写。
参考如下
#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>
// 抽象类：共同课程
class AbstractClass {
protected:
std::vector<double> scores; // 成绩
public:
virtual void inputScores() = 0; // 输入成绩
virtual void outputScores() = 0; // 输出成绩
virtual double getAverageScore() = 0; // 平均分
virtual double getHighestScore() = 0; // 最高分
virtual double getLowestScore() = 0; // 最低分
};
// 生物医学工程班
class BMEClass : public AbstractClass {
public:
void inputScores() override {
std::cout << "Enter scores for BME class: " << std::endl;
double score;
for (int i = 0; i < 4; ++i) {
std::cin >> score;
scores.push_back(score);
}
}
void outputScores() override {
std::cout << "Scores for BME class: ";
for (double score : scores) {
std::cout << score << " ";
}
std::cout << std::endl;
}
double getAverageScore() override {
double sum = std::accumulate(scores.begin(), scores.end(), 0.0);
return sum / scores.size();
}
double getHighestScore() override {
return *std::max_element(scores.begin(), scores.end());
}
double getLowestScore() override {
return *std::min_element(scores.begin(), scores.end());
}
};
// 生物工程班
class BEClass : public AbstractClass {
public:
void inputScores() override {
std::cout << "Enter scores for BE class: " << std::endl;
double score;
for (int i = 0; i < 5; ++i) {
std::cin >> score;
scores.push_back(score);
}
}
void outputScores() override {
std::cout << "Scores for BE class: ";
for (double score : scores) {
std::cout << score << " ";
}
std::cout << std::endl;
}
double getAverageScore() override {
double sum = std::accumulate(scores.begin(), scores.end(), 0.0);
return sum / scores.size();
}
double getHighestScore() override {
return *std::max_element(scores.begin(), scores.end());
}
double getLowestScore() override {
return *std::min_element(scores.begin(), scores.end());
}
};
int main() {
BMEClass bmeClass;
BEClass beClass;
// 输入成绩
bmeClass.inputScores();
beClass.inputScores();
// 输出成绩
bmeClass.outputScores();
beClass.outputScores();
// 计算并输出平均分、最高分、最低分
std::cout << "Average score for BME class: " << bmeClass.getAverageScore() << std::endl;
std::cout << "Highest score
for BME class: " << bmeClass.getHighestScore() << std::endl;
std::cout << "Lowest score for BME class: " << bmeClass.getLowestScore() << std::endl;
std::cout << "Average score for BE class: " << beClass.getAverageScore() << std::endl;
std::cout << "Highest score for BE class: " << beClass.getHighestScore() << std::endl;
std::cout << "Lowest score for BE class: " << beClass.getLowestScore() << std::endl;
return 0;
}
可以借鉴下
int main()
{
Slist* List = ListInit();
ListLoad(List);
int input = 0;
do
{
menu();
printf("请选择:>");
scanf("%d",&input);
switch(input)
{
case 1:
ListPushBack(List);
break;
case 2:
ListDelet(List);
case 3:
ListPrint(List);
break;
case 4:
ListSort(List);
break;
case 5:
ListSearch(List);
break;
case 0:
ListSave(List);
printf("保存成功，退出!\n");
break;
}
}
while(input);
return 0;
}
java实现的代码，你看看，可以参考一下。
抽象类 abstractClass：
abstract class abstractClass {
protected int[][] scores;
protected String[] courses;
public abstract void inputScores(); // 输入成绩
public abstract void show(); // 输出统计结果
}
生物医学工程班 BMEclass：
class BMEclass extends abstractClass {
public BMEclass() {
courses = new String[]{"数学", "英语", "物理", "电子", "机械"};
scores = new int[4][courses.length];
}
@Override
public void inputScores() {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入生物医学工程班4名学生的成绩：");
for (int i = 0; i < scores.length; i++) {
System.out.print("请输入第" + (i + 1) + "名学生的成绩：");
for (int j = 0; j < courses.length; j++) {
System.out.print(courses[j] + "：");
scores[i][j] = scanner.nextInt();
}
}
}
@Override
public void show() {
System.out.println("生物医学工程专业:");
// 统计各门课程的平均分
System.out.println("各门课程平均分为：");
double[] avgScores = new double[courses.length];
for (int j = 0; j < courses.length; j++) {
double sum = 0;
for (int i = 0; i < scores.length; i++) {
sum += scores[i][j];
}
avgScores[j] = sum / scores.length;
System.out.println(courses[j] + "：" + avgScores[j]);
}
// 统计各门课程的最高分
System.out.println("各门课程最高分为：");
for (int j = 0; j < courses.length; j++) {
int maxScore = 0;
for (int i = 0; i < scores.length; i++) {
maxScore = Math.max(maxScore, scores[i][j]);
}
System.out.println(courses[j] + "：" + maxScore);
}
// 统计各门课程的最低分
System.out.println("各门课程最低分为：");
for (int j = 0; j < courses.length; j++) {
int minScore = 100;
for (int i = 0; i < scores.length; i++) {
minScore = Math.min(minScore, scores[i][j]);
}
System.out.println(courses[j] + "：" + minScore);
}
}
}
生物工程班 BEclass：
class BEclass extends abstractClass {
public BEclass() {
courses = new String[]{"数学", "英语", "物理", "分子", "生化"};
scores = new int[5][courses.length];
}
@Override
public void inputScores() {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入生物工程班5名学生的成绩：");
for (int i = 0; i < scores.length; i++) {
System.out.print("请输入第" + (i + 1) + "名学生的成绩：");
for (int j = 0; j < courses.length; j++) {
System.out.print(courses[j] + "：");
scores[i][j] = scanner.nextInt();
}
}
}
@Override
public void show() {
System.out.println("生物工程专业:");
// 统计各门课程的平均分
System.out.println("各门课程平均分为：");
double[] avgScores = new double[courses.length];
for (int j = 0; j < courses.length; j++) {
double sum = 0;
for (int i = 0; i < scores.length; i++) {
sum += scores[i][j];
}
avgScores[j] = sum / scores.length;
System.out.println(courses[j] + "：" + avgScores[j]);
}
// 统计各门课程的最高分
System.out.println("各门课程最高分为：");
for (int j = 0; j < courses.length; j++) {
int maxScore = 0;
for (int i = 0; i < scores.length; i++) {
maxScore = Math.max(maxScore, scores[i][j]);
}
System.out.println(courses[j] + "：" + maxScore);
}
// 统计各门课程的最低分
System.out.println("各门课程最低分为：");
for (int j = 0; j < courses.length; j++) {
int minScore = 100;
for (int i = 0; i < scores.length; i++) {
minScore = Math.min(minScore, scores[i][j]);
}
System.out.println(courses[j] + "：" + minScore);
}
}
}
主函数 Main：
class Main {
public static void main(String[] args) {
BMEclass bmeClass = new BMEclass();
bmeClass.inputScores();
bmeClass.show();
BEclass beClass = new BEclass();
beClass.inputScores();
beClass.show();
}
}
可以参考下
#include<iostream>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
using namespace std;
typedef struct PNode*LinkList;
typedef struct PNode{
int stdio;
char name[30];
double chinese;
double math;
double english;
double politics;
double sum;
PNode *next;
}PNode;
int main(){
LinkList llist=(LinkList)malloc(sizeof(PNode));
llist->next=NULL;
int a,b=1;
while(b){
printf("\n-----------------------学生成绩管理系统-----------------------\n");
printf("请选择你需要的功能:\n");
printf(" 1.查找 2.插入 3.排序 4.展示 5.删除 6.退出\n");
scanf("%d",&a);
switch(a){
case 1:printf("\n-----------------------学生成绩查找功能-----------------------\n"); check(llist);break;
case 2:printf("\n-----------------------学生成绩插入功能-----------------------\n"); input(llist);break;
case 3:printf("\n-----------------------学生成绩排序功能-----------------------\n"); sortList(llist);break;
case 4:printf("\n-----------------------学生成绩展示功能-----------------------\n"); display(llist);break;
case 5:printf("\n-----------------------学生成绩删除功能-----------------------\n"); deleteList(llist);break;
case 6:b = 0; break;
default:printf("输入有误!请重新输入!\n");
}
}
printf("\n-----------------------已退出成绩管理系统-----------------------\n");
return 0;
}
这种题用ai吧
没人解决？
#include <iostream>
#include <vector>
#include <algorithm>
// 抽象类 AbstractClass
class AbstractClass {
protected:
std::vector<double> scores; // 成绩列表
public:
// 纯虚函数，子类必须实现
virtual void inputScores() = 0;
virtual void displayStats() = 0;
};
// 生物医学工程班 BMEClass
class BMEClass : public AbstractClass {
public:
void inputScores() override {
std::cout << "请输入生物医学工程班的学生成绩：" << std::endl;
double score;
for (int i = 0; i < 4; ++i) {
std::cin >> score;
scores.push_back(score);
}
}
void displayStats() override {
std::cout << "生物医学工程班各门课程的统计信息：" << std::endl;
std::cout << "平均分：" << getAverageScore() << std::endl;
std::cout << "最高分：" << getMaxScore() << std::endl;
std::cout << "最低分：" << getMinScore() << std::endl;
std::cout << "......" << std::endl;
}
private:
double getAverageScore() {
double sum = 0;
for (double score : scores) {
sum += score;
}
return sum / scores.size();
}
double getMaxScore() {
return *std::max_element(scores.begin(), scores.end());
}
double getMinScore() {
return *std::min_element(scores.begin(), scores.end());
}
};
// 生物工程班 BEClass
class BEClass : public AbstractClass {
public:
void inputScores() override {
std::cout << "请输入生物工程班的学生成绩：" << std::endl;
double score;
for (int i = 0; i < 5; ++i) {
std::cin >> score;
scores.push_back(score);
}
}
void displayStats() override {
std::cout << "生物工程班各门课程的统计信息：" << std::endl;
std::cout << "平均分：" << getAverageScore() << std::endl;
std::cout << "最高分：" << getMaxScore() << std::endl;
std::cout << "最低分：" << getMinScore() << std::endl;
std::cout << "......" << std::endl;
}
private:
double getAverageScore() {
double sum = 0;
for (double score : scores) {
sum += score;
}
return sum / scores.size();
}
double getMaxScore() {
return *std::max_element(scores.begin(), scores.end());
}
double getMinScore() {
return *std::min_element(scores.begin(), scores.end());
}
};
int main() {
// 创建对象
BMEClass bmeClass;
BEClass beClass;
// 输入成绩
bmeClass.inputScores();
beClass.inputScores();
// 输出统计信息
bmeClass.displayStats();
beClass.displayStats();
return 0;
}
该回答引用GPT与博主@晓码自在合作编写：
这里是带注释的C语言实现:
c
// abstractClass: 抽象类,包含两个班级的共同课程
struct abstractClass {
int math[9]; // 数学成绩
int english[9]; // 英语成绩
int physics[9]; // 物理成绩
};
// BMEclass: 生物医学工程班,继承abstractClass,添加自己的课程
struct BMEclass extends abstractClass {
int electronic[4]; // 电子成绩
int mechanical[4];// 机械成绩
};
// BEclass: 生物工程班,继承abstractClass,添加自己的课程
struct BEclass extends abstractClass {
int molecular[5]; // 分子成绩
int biochemistry[5]; // 生化成绩
};
// 计算平均分
float avgScore(int scores[], int n) {
float sum = 0;
for (int i = 0; i < n; i++) {
sum += scores[i];
}
return sum / n;
}
// 计算最高分
int maxScore(int scores[], int n) {
int max = 0;
for (int i = 0; i < n; i++) {
if (max < scores[i])
max = scores[i];
}
return max;
}
// 计算最低分
int minScore(int scores[], int n) {
int min = 100; // 假定满分100
for (int i = 0; i < n; i++) {
if (min > scores[i])
min = scores[i];
}
return min;
}
int main() {
// 创建BMEclass对象,输入4名学生的成绩
struct BMEclass bme;
bme.math[0] = 80; bme.math[1] = 90; bme.math[2] = 85; bme.math[3] = 95;
...
// 创建BEclass对象,输入5名学生的成绩
struct BEclass be;
be.math[0] = 82; be.math[1] = 88; be.math[2] = 83; be.math[3] = 91; be.math[4] = 97;
...
// 计算BMEclass各门课程的平均分、最高分、最低分
float bme_avg_math = avgScore(bme.math, 4);
int bme_max_math = maxScore(bme.math, 4);
int bme_min_math = minScore(bme.math, 4);
...
// 计算BEclass各门课程的平均分、最高分、最低分
float be_avg_math = avgScore(be.math, 5);
int be_max_math = maxScore(be.math, 5);
int be_min_math = minScore(be.math, 5);
...
}
这个程序使用了继承的方法,建立abstractClass作为抽象基类,BMEclass和BEclass继承它并添加各自的课程。各个类的课程采用数组表示,然后定义avgScore()、maxScore()和minScore()函数分别计算平均分、最高分和最低分。
在main()函数中,创建BMEclass和BEclass的对象,输入各自的成绩,并调用上述函数计算各门课程的平均分、最高分和最低分。
以下答案由GPT-3.5大模型与博主波罗歌共同编写：
首先，我们需要创建一个抽象类AbstractClass，表示班级的基本信息和课程列表。由于这是一个抽象类，我们可以在这里定义一些抽象方法，以便派生类实现。
from abc import ABC, abstractmethod
class AbstractClass(ABC):
def __init__(self, name, num_students, courses):
self.name = name
self.num_students = num_students
self.courses = courses
@abstractmethod
def calculate_averages(self):
pass
@abstractmethod
def calculate_max_min(self):
pass
接着，我们可以创建两个具体的子类，BMEClass和BEClass。这两个子类将实现抽象类中的抽象方法，并且还会添加一些其他的方法。
class BMEClass(AbstractClass):
def __init__(self, num_students):
self.name = "生物医学工程"
self.num_students = num_students
self.courses = ['数学', '英语', '物理', '电子', '机械']
self.grades = []
def add_grade(self, grade):
self.grades.append(grade)
def calculate_averages(self):
averages = []
for course in self.courses:
total = 0
count = 0
for grade in self.grades:
if course in grade:
total += grade[course]
count += 1
if count > 0:
average = total / count
averages.append((course, average))
return averages
def calculate_max_min(self):
max_min = []
for course in self.courses:
values = []
for grade in self.grades:
if course in grade:
values.append(grade[course])
if len(values) > 0:
max_val = max(values)
min_val = min(values)
max_min.append((course, max_val, min_val))
return max_min
class BEClass(AbstractClass):
def __init__(self, num_students):
self.name = "生物工程"
self.num_students = num_students
self.courses = ['数学', '英语', '物理', '分子', '生化']
self.grades = []
def add_grade(self, grade):
self.grades.append(grade)
def calculate_averages(self):
averages = []
for course in self.courses:
total = 0
count = 0
for grade in self.grades:
if course in grade:
total += grade[course]
count += 1
if count > 0:
average = total / count
averages.append((course, average))
return averages
def calculate_max_min(self):
max_min = []
for course in self.courses:
values = []
for grade in self.grades:
if course in grade:
values.append(grade[course])
if len(values) > 0:
max_val = max(values)
min_val = min(values)
max_min.append((course, max_val, min_val))
return max_min
我们可以使用这些类来处理成绩数据。首先，我们需要实例化这些班级。
bme_class = BMEClass(4)
be_class = BEClass(5)
接着，我们需要将成绩添加到相应的班级中。需要注意的是，成绩应该是一个字典，其中键是课程名称，值是成绩。
bme_class.add_grade({'数学': 90, '英语': 80, '物理': 85, '电子': 70, '机械': 75})
bme_class.add_grade({'数学': 85, '英语': 75, '物理': 80, '电子': 65, '机械': 70})
bme_class.add_grade({'数学': 80, '英语': 70, '物理': 75, '电子': 60, '机械': 65})
bme_class.add_grade({'数学': 75, '英语': 65, '物理': 70, '电子': 55, '机械': 60})
be_class.add_grade({'数学': 90, '英语': 80, '物理': 85, '分子': 80, '生化': 75})
be_class.add_grade({'数学': 85, '英语': 75, '物理': 80, '分子': 75, '生化': 70})
be_class.add_grade({'数学': 80, '英语': 70, '物理': 75, '分子': 70, '生化': 65})
be_class.add_grade({'数学': 75, '英语': 65, '物理': 70, '分子': 65, '生化': 60})
be_class.add_grade({'数学': 70, '英语': 60, '物理': 65, '分子': 60, '生化': 55})
现在，我们可以使用这些类计算各门课程的平均分、最高分和最低分。
print(bme_class.calculate_averages())
print(bme_class.calculate_max_min())
print(be_class.calculate_averages())
print(be_class.calculate_max_min())
这将输出：
[('数学', 82.5), ('英语', 72.5), ('物理', 77.5)]
[('数学', 90, 75), ('英语', 80, 65), ('物理', 85, 70), ('电子', 70, 55), ('机械', 75, 60)]
[('数学', 80), ('英语', 70), ('物理', 75), ('分子', 70), ('生化', 65)]
[('数学', 90, 70), ('英语', 80, 60), ('物理', 85, 65), ('分子', 80, 60), ('生化', 75, 55)]
如果我的回答解决了您的问题，请采纳！
引用ChatGPT部分内容作答：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// 抽象类
typedef struct {
char* name; // 课程名称
int* scores; // 成绩数组
int num_students; // 学生人数
} abstractClass;
// 生物医学工程班
typedef struct {
abstractClass base; // 继承抽象类
int electronics; // 电子成绩
int mechanics; // 机械成绩
} BMEclass;
// 生物工程班
typedef struct {
abstractClass base; // 继承抽象类
int molecular; // 分子成绩
int biochemistry; // 生化成绩
} BEclass;
// 计算平均分
float calc_average(int* scores, int num_students) {
int sum = 0;
for (int i = 0; i < num_students; i++) {
sum += scores[i];
}
return (float)sum / num_students;
}
// 计算最高分
int calc_max(int* scores, int num_students) {
int max = scores[0];
for (int i = 1; i < num_students; i++) {
if (scores[i] > max) {
max = scores[i];
}
}
return max;
}
// 计算最低分
int calc_min(int* scores, int num_students) {
int min = scores[0];
for (int i = 1; i < num_students; i++) {
if (scores[i] < min) {
min = scores[i];
}
}
return min;
}
// 输出成绩统计信息
void print_stats(char* name, int* scores, int num_students) {
printf("%s: 平均分 %.2f, 最高分 %d, 最低分 %d\n", name, calc_average(scores, num_students), calc_max(scores, num_students), calc_min(scores, num_students));
}
int main() {
// 初始化生物医学工程班
BMEclass bme = {
.base = {
.name = "共同课程",
.scores = (int*)malloc(5 * sizeof(int)),
.num_students = 4
},
.electronics = 90,
.mechanics = 85
};
bme.base.scores[0] = 80;
bme.base.scores[1] = 75;
bme.base.scores[2] = 85;
bme.base.scores[3] = 90;
// 初始化生物工程班
BEclass be = {
.base = {
.name = "共同课程",
.scores = (int*)malloc(5 * sizeof(int)),
.num_students = 5
},
.molecular = 95,
.biochemistry = 85
};
be.base.scores[0] = 90;
be.base.scores[1] = 85;
be.base.scores[2] = 95;
be.base.scores[3] = 80;
be.base.scores[4] = 90;
// 输出生物医学工程班成绩统计信息
printf("生物医学工程班\n");
print_stats("数学", bme.base.scores, bme.base.num_students);
print_stats("英语", bme.base.scores, bme.base.num_students);
print_stats("物理", bme.base.scores, bme.base.num_students);
printf("电子: %d\n", bme.electronics);
printf("机械: %d\n", bme.mechanics);
// 输出生物工程班成绩统计信息
printf("\n生物工程班\n");
print_stats("数学", be.base.scores, be.base.num_students);
print_stats("英语", be.base.scores, be.base.num_students);
print_stats("物理", be.base.scores, be.base.num_students);
printf("分子: %d\n", be.molecular);
printf("生化: %d\n", be.biochemistry);
// 释放内存
free(bme.base.scores);
free(be.base.scores);
return 0;
}
输出结果如下：
生物医学工程班
数学: 平均分 82.50, 最高分 90, 最低分 75
英语: 平均分 82.50, 最高分 90, 最低分 75
物理: 平均分 83.75, 最高分 90, 最低分 75
电子: 90
机械: 85
生物工程班
数学: 平均分 88.00, 最高分 95, 最低分 80
英语: 平均分 85.00, 最高分 95, 最低分 80
物理: 平均分 89.00, 最高分 95, 最低分 80
分子: 95
生化: 85