建立一个对象数组，内放5个学生的数据（学号、成绩等），设立一个函数max,用指向对象的指针作函数参数，在max函数中找出5个学生中成绩最高者，并输出其学号; 建立静态数据成员，实现平均分计算

### 回答1：
题目要求我们创建一个对象数组，其中包含5个学生的数据（学号、成绩等），并定义一个函数max，使用指向对象的指针作为参数，在max函数中找到成绩最高的学生，并输出其学号。

我们可以先定义一个学生类，包含学号和成绩两个成员变量。然后定义一个对象数组，用5个学生的数据初始化这个数组。接着定义一个max函数，使用指向学生对象的指针作为参数，遍历数组，在其中找到成绩最高的学生，并把他的学号输出即可。

另外，题目还要求我们创建一个静态数据成员，用于实现平均分计算。我们可以在学生类中定义一个静态数据成员sum和count，用来表示总分和学生数量。在每次创建学生对象时，更新sum和count。在需要计算平均分时，可以直接使用这两个静态数据成员计算即可。

### 回答2：
首先，我们需要定义一个学生类，包含学号、成绩等属性，并实现一些相关的方法。

class Student{
private:
    int id;
    int score;
public:
    Student(int i, int s):id(i),score(s){}
    int getId() const{ return id; }
    int getScore() const{ return score; }
    static double getAverageScore(const Student* students, int count);
};

我们需要实现一个函数来计算5个学生中成绩最高者，并输出其学号。考虑到参数是一个指向对象的指针，我们可以在函数中使用指针的方式对对象进行操作。首先，我们可以指定一个初始的最高成绩和对应的学生指针，然后遍历数组，通过判断当前元素的成绩是否大于最高成绩，从而更新最高成绩和对应的学生指针。

void max(Student *students[], int count){
    int maxScore = -1;
    Student *maxStudent = nullptr;
    for(int i=0; i<count; i++){
        if(students[i]->getScore() > maxScore){
            maxScore = students[i]->getScore();
            maxStudent = students[i];
        }
    }
    cout << "最高成绩的学生的学号为：" << maxStudent->getId() << endl;
}

最后，我们需要实现一个静态数据成员来计算学生数组的平均分，这里我们可以直接在类的定义中声明和实现该方法。由于该方法不涉及到特定的对象，因此可以设为静态的。

class Student{
private:
    int id;
    int score;
public:
    Student(int i, int s):id(i),score(s){}
    int getId() const{ return id; }
    int getScore() const{ return score; }
    static double getAverageScore(const Student* students, int count);
};

double Student::getAverageScore(const Student* students, int count){
    int totalScore = 0;
    for(int i=0; i<count; i++){
        totalScore += students[i].getScore();
    }
    return static_cast<double>(totalScore)/count;
}

在使用时，我们可以先创建一个学生数组，然后通过指针数组来操作其中的元素，最后调用max函数和getAverageScore方法即可。

int main(){
    Student students[] = {{1, 80}, {2, 90},{3, 70}, {4, 85}, {5, 60}};
    Student* ptr[5];
    for(int i=0; i<5; i++){
        ptr[i] = &students[i];
    }
    max(ptr, 5);
    cout << "学生们的平均分为：" << Student::getAverageScore(students, 5) << endl;
    return 0;
}

完整的代码如下：

#include<iostream>
using namespace std;

class Student{
private:
    int id;
    int score;
public:
    Student(int i, int s):id(i),score(s){}
    int getId() const{ return id; }
    int getScore() const{ return score; }
    static double getAverageScore(const Student* students, int count);
};

void max(Student *students[], int count){
    int maxScore = -1;
    Student *maxStudent = nullptr;
    for(int i=0; i<count; i++){
        if(students[i]->getScore() > maxScore){
            maxScore = students[i]->getScore();
            maxStudent = students[i];
        }
    }
    cout << "最高成绩的学生的学号为：" << maxStudent->getId() << endl;
}

double Student::getAverageScore(const Student* students, int count){
    int totalScore = 0;
    for(int i=0; i<count; i++){
        totalScore += students[i].getScore();
    }
    return static_cast<double>(totalScore)/count;
}

int main(){
    Student students[] = {{1, 80}, {2, 90},{3, 70}, {4, 85}, {5, 60}};
    Student* ptr[5];
    for(int i=0; i<5; i++){
        ptr[i] = &students[i];
    }
    max(ptr, 5);
    cout << "学生们的平均分为：" << Student::getAverageScore(students, 5) << endl;
    return 0;
}

### 回答3：
首先，我们需要定义一个学生类。该类需要包括学号和成绩这两个数据成员，以及相应的构造函数和成员函数。

class Student {
public:
    int id;        //学生学号
    double score;  //学生成绩

    Student(int i, double s) {
        id = i;
        score = s;
    }

    void setId(int i) {
        id = i;
    }

    int getId() {
        return id;
    }

    void setScore(double s) {
        score = s;
    }

    double getScore() {
        return score;
    }
};

接下来，我们需要创建一个包含5个学生数据的对象数组，并定义一个名为max的函数，用于找出这5个学生中成绩最高的那个。该函数的参数是一个指向Student对象的指针数组。

在max函数中，我们可以使用循环和if语句来比较每个学生的成绩大小，从而找出最高分。在比较完毕后，我们可以输出对应的学号。

void max(Student* students[]) {
    double maxScore = students[0]->getScore();  //初始化最高分为第一个学生的成绩
    int maxId = students[0]->getId();           //初始化最高分对应的学号为第一个学生的学号
    for (int i = 1; i < 5; i++) {
        if (students[i]->getScore() > maxScore) {
            maxScore = students[i]->getScore();
            maxId = students[i]->getId();
        }
    }
    cout << "成绩最高的学生学号为：" << maxId << endl;
}

最后，我们可以利用静态数据成员来求出5个学生的平均分。我们定义一个名为totalScore和count的静态变量，用于存储所有学生的总成绩和学生人数。在创建对象数组时，我们可以遍历数组，将每个学生的成绩加起来，并将学生人数加1。最后，我们可以在main函数中输出平均分。

class Student {
public:
    ...
    static double totalScore;  //总成绩
    static int count;          //学生人数

    ...
};

double Student::totalScore = 0;
int Student::count = 0;

int main() {
    Student students[5] = {
        Student(1, 90),
        Student(2, 85),
        Student(3, 93),
        Student(4, 88),
        Student(5, 92)
    };

    //计算平均分并输出
    for (int i = 0; i < 5; i++) {
        Student::totalScore += students[i].getScore();
        Student::count++;
    }
    double avgScore = Student::totalScore / Student::count;
    cout << "5个学生的平均分为：" << avgScore << endl;

    //调用max函数找出成绩最高的学生
    Student* ps[5];
    for (int i = 0; i < 5; i++) {
        ps[i] = &students[i];
    }
    max(ps);
    return 0;
}

通过以上代码，我们成功实现了建立对象数组，定义max函数找出成绩最高的学生，并利用静态数据成员计算平均分的功能。