创建查询多门不及格成绩，查询至少有两门不及格成绩的学生姓名、系别。

假设有如下的学生成绩表（表名为score）：

| 学生姓名 | 系别 | 课程名称 | 成绩 |
| -------- | ---- | -------- | ---- |
| 张三 | 计算机 | 数学 | 80 |
| 张三 | 计算机 | 英语 | 60 |
| 李四 | 电子 | 数学 | 70 |
| 李四 | 电子 | 英语 | 50 |
| 王五 | 计算机 | 数学 | 45 |
| 王五 | 计算机 | 英语 | 30 |
| 赵六 | 电子 | 数学 | 75 |
| 赵六 | 电子 | 英语 | 80 |

则查询语句为：

SELECT 学生姓名, 系别
FROM score
WHERE 成绩 < 60
GROUP BY 学生姓名, 系别
HAVING COUNT(*) >= 2;

查询结果为：

| 学生姓名 | 系别 |
| -------- | ------ |
| 张三 | 计算机 |
| 李四 | 电子 |

相关问题

多表查询挂科超过两门(包括两门)的学生姓名和班级

假设有三张表，分别是学生表（student），课程表（course），成绩表（score），其中学生表和课程表的关系是多对多，成绩表是通过学生表和课程表的主键构成的联合主键来表示一个学生在一门课程中的成绩。

我们可以先通过以下 SQL 语句来找到挂科超过两门的学生：

SELECT student.name, student.class
FROM student
INNER JOIN score ON student.id = score.student_id
WHERE score.grade < 60
GROUP BY student.id
HAVING COUNT(*) >= 2;

上述 SQL 语句通过 INNER JOIN 连接学生表和成绩表，通过 WHERE 子句来筛选出成绩不及格的记录，然后通过 GROUP BY 和 HAVING 来进行分组和筛选，最终得出挂科超过两门的学生姓名和班级。

设计一个学生类，其中数据成员有学号、姓名、年龄、3门课程的成绩，以及若干成员函数。并利用这个类建立一个对象数组。（1）求第一门课的平均成绩；（2）找出有两门以上课程不及格的学生，输出他们的学号和全部课

### 回答1：
程成绩；（3）按照平均成绩从高到低排序输出所有学生的学号、姓名、年龄和平均成绩。

设计思路：

1. 定义一个学生类，包含学号、姓名、年龄、3门课程的成绩等数据成员，以及计算平均成绩的成员函数。

2. 建立一个对象数组，存储多个学生的信息。

3. 实现求第一门课的平均成绩的函数，遍历所有学生的第一门课成绩并求平均值。

4. 实现找出有两门以上课程不及格的学生的函数，遍历所有学生的成绩并统计不及格科目数，输出符合条件的学生信息。

5. 实现按照平均成绩从高到低排序输出所有学生信息的函数，使用冒泡排序或快速排序等算法进行排序。

代码实现：

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

class Student {
public:
    string id; // 学号
    string name; // 姓名
    int age; // 年龄
    int score1, score2, score3; // 3门课程的成绩

    // 计算平均成绩
    double getAvgScore() {
        return (score1 + score2 + score3) / 3.;
    }

    // 输出学生信息
    void printInfo() {
        cout << id << "\t" << name << "\t" << age << "\t"
             << score1 << "\t" << score2 << "\t" << score3 << endl;
    }
};

int main() {
    const int N = 5; // 学生数量
    Student students[N] = {
        {"001", "张三", 18, 80, 90, 70},
        {"002", "李四", 19, 70, 60, 80},
        {"003", "王五", 20, 90, 80, 85},
        {"004", "赵六", 21, 60, 70, 75},
        {"005", "钱七", 22, 85, 90, 95}
    };

    // 求第一门课的平均成绩
    double avgScore1 = ;
    for (int i = ; i < N; i++) {
        avgScore1 += students[i].score1;
    }
    avgScore1 /= N;
    cout << "第一门课的平均成绩为：" << avgScore1 << endl;

    // 找出有两门以上课程不及格的学生
    cout << "两门以上课程不及格的学生：" << endl;
    for (int i = ; i < N; i++) {
        int cnt = ; // 不及格科目数
        if (students[i].score1 < 60) cnt++;
        if (students[i].score2 < 60) cnt++;
        if (students[i].score3 < 60) cnt++;
        if (cnt >= 2) {
            students[i].printInfo();
        }
    }

    // 按照平均成绩从高到低排序输出所有学生信息
    for (int i = ; i < N - 1; i++) {
        for (int j = ; j < N - i - 1; j++) {
            if (students[j].getAvgScore() < students[j + 1].getAvgScore()) {
                swap(students[j], students[j + 1]);
            }
        }
    }
    cout << "按照平均成绩从高到低排序输出所有学生信息：" << endl;
    for (int i = ; i < N; i++) {
        students[i].printInfo();
    }

    return ;
}

### 回答2：
设计一个学生类，其中数据成员有学号、姓名、年龄、3门课程的成绩，并利用这个类建立一个对象数组。可以利用以下代码来定义这个类：

class Student {
private:
    int id; // 学号
    string name; // 姓名
    int age; // 年龄
    double scores[3]; // 3门课程的成绩
public:
    Student(int id, string name, int age, double score1, double score2, double score3) {
        this->id = id;
        this->name = name;
        this->age = age;
        this->scores[0] = score1;
        this->scores[1] = score2;
        this->scores[2] = score3;
    }
    double getAverageScore() {
        return (scores[0] + scores[1] + scores[2]) / 3.0;
    }
    bool isFailed() {
        int count = 0;
        for (int i = 0; i < 3; i++) {
            if (scores[i] < 60) {
                count++;
            }
        }
        return count >= 2;
    }
    void printInfo() {
        cout << "学号：" << id << "，姓名：" << name << "，年龄：" << age << "，成绩：";
        for (int i = 0; i < 3; i++) {
            cout << scores[i] << " ";
        }
        cout << endl;
    }
};

这个类有四个成员函数，分别是构造函数、计算平均成绩的函数、判断是否有两门及以上不及格的函数和输出学生信息的函数。其中，在构造函数中需要对学号、姓名、年龄和课程成绩进行初始化。

接下来，可以利用这个类定义一个对象数组，并进行相应的操作：

int main() {
    int n = 5; // 学生数量
    Student students[n] = {
        Student(1, "小明", 18, 80, 70, 90),
        Student(2, "小红", 19, 60, 70, 50),
        Student(3, "小李", 20, 70, 80, 60),
        Student(4, "小王", 18, 90, 80, 70),
        Student(5, "小张", 19, 50, 60, 70)
    };

    // 求第一门课的平均成绩
    double sum = 0;
    for (int i = 0; i < n; i++) {
        sum += students[i].scores[0];
    }
    double averageScore = sum / n;
    cout << "第一门课的平均成绩为：" << averageScore << endl;

    // 找出有两门以上课程不及格的学生，输出他们的学号和全部课
    cout << "以下为有两门以上课程不及格的学生信息：" << endl;
    for (int i = 0; i < n; i++) {
        if (students[i].isFailed()) {
            students[i].printInfo();
        }
    }

    return 0;
}

在这个程序中，首先定义了一个学生数组，包含了5个学生的信息。然后，通过遍历整个数组，计算第一门课的平均成绩。接下来，再次遍历整个数组，找出不及格课程数大于等于2的学生，输出他们的信息。

综上所述，通过这个学生类和相应的代码，可以方便地计算学生成绩，并找出不及格学生。同时，也可以方便地处理多个学生的信息。

### 回答3：
学生类是面向对象程序设计中的常见实体类，其数据成员包括学号、姓名、年龄、课程成绩等属性，成员函数包括构造函数、析构函数、赋值函数、输出函数等。

学生类定义如下：

class Student{
private:
    string stu_id;//学号
    string stu_name;//学生姓名
    int stu_age;//学生年龄
    double course1_grade;//第一门课程成绩
    double course2_grade;//第二门课程成绩
    double course3_grade;//第三门课程成绩
public:
    Student();//无参构造函数
    Student(string id,string name,int age,double c1,double c2,double c3);//有参构造函数
    ~Student();//析构函数
    Student& operator=(const Student& s);//赋值函数
    void print();//输出学生信息
    double get_course1_grade();//获取第一门课程的成绩
    double get_course2_grade();//获取第二门课程的成绩
    double get_course3_grade();//获取第三门课程的成绩
    bool is_failed();//判断学生是否有课程不及格
    int count_failed_course();//统计学生不及格的课程数
};

其中，无参构造函数用于创建一个空的学生对象；有参构造函数用于创建一个具有学号、姓名、年龄和3门课程成绩的学生对象，析构函数用于释放学生对象占用的内存空间，赋值函数用于实现学生对象之间的赋值操作，输出函数用于将学生的信息打印到控制台上，而获取第一门课程、第二门课程、第三门课程的成绩的函数用于获取学生的课程成绩。is_failed()函数用于判断学生是否有不及格的课程，count_failed_course()函数用于统计学生不及格的课程数量。

利用学生类创建一个对象数组如下：

int main(){
    Student stu[5] = {
        Student("001","张三",20,78,89,67),
        Student("002","李四",19,90,87,56),
        Student("003","王五",21,56,67,87),
        Student("004","赵六",18,75,42,86),
        Student("005","陈七",20,67,81,72)
    };
    return 0;
}

为了求第一门课的平均成绩，可以遍历学生数组，累加每个学生的第一门课成绩，最后计算平均成绩。

double avg_course1_grade(Student stu[],int n){
    double sum = 0;
    for(int i = 0;i < n;i++){
        sum += stu[i].get_course1_grade();
    }
    return sum/n;
}

为了找出有两门以上课程不及格的学生，可以遍历学生数组，统计不及格课程数量，判断是否有大于等于2门课程不及格的学生，如果有，则输出其学号和全部课程。

void print_failed_student(Student stu[],int n){
    cout<<"不及格学生信息:"<<endl;
    bool any_failed = false;
    for(int i = 0;i < n;i++){
        int fail_count = stu[i].count_failed_course();
        if(fail_count >= 2){
            any_failed = true;
            cout<<"学号:"<<stu[i].get_stu_id()<<endl;
            cout<<"姓名:"<<stu[i].get_stu_name()<<endl;
            cout<<"年龄:"<<stu[i].get_stu_age()<<endl;
            cout<<"所有课程成绩:"<<stu[i].get_course1_grade()<<" "<<stu[i].get_course2_grade()<<" "<<stu[i].get_course3_grade()<<endl;
        }
    }
    if(!any_failed){
        cout<<"没有不及格两门及以上课程的学生."<<endl;
    }
}

以上，是关于设计学生类的回答。