1．建立一个对象数组，内放5个学生的数据(学号、成绩)，用指针指向数组首元素，输出第1,3,5个学生的数据。

参考代码1

#include <iostream>
#include <string>

// 定义一个学生类，包含学号和成绩
class Student {
public:
    std::string student_id;
    float score;

    // 构造函数
    Student(std::string id, float sc) : student_id(id), score(sc) {}

    // 显示学生信息的方法
    void displayInfo() {
        std::cout << "学号：" << student_id << "，成绩：" << score << std::endl;
    }
};

int main() {
    // 创建一个包含5个学生数据的数组
    Student students[] = {
        Student("S001", 90.5),
        Student("S002", 85.0),
        Student("S003", 92.5),
        Student("S004", 88.0),
        Student("S005", 91.0)
    };

    // 使用指针指向数组的首元素
    Student *ptr = students;

    // 输出第1个学生的数据
    (ptr + 0)->displayInfo();

    // 输出第3个学生的数据
    (ptr + 2)->displayInfo();

    // 输出第5个学生的数据
    (ptr + 4)->displayInfo();

    return 0;
}

代码分析1

在这个示例中，我们首先定义了一个Student类，其中包含了学生的学号和成绩。在Student类中，我们还定义了一个displayInfo方法，用于输出学生的信息。

在main函数中，我们创建了一个名为students的Student对象数组，并初始化了5个学生的数据。然后，我们声明了一个Student类型的指针ptr，并将它指向数组的首元素。最后，我们通过指针加上偏移量来访问特定的学生对象，并调用它们的displayInfo方法来输出学生的数据。

2．建立一个对象数组，内放5个学生的数据(学号、成绩)，设立一个函数max，用指向对象的指针作函数参数，在max函数中找出5个学生中成绩最高者，并输出其学号。

参考代码2

#include <iostream>

// 定义一个学生类，包含学号和成绩
class Student {
public:
    std::string student_id;
    float score;

    // 构造函数
    Student(std::string id, float sc) : student_id(id), score(sc) {}
};

// 函数max，找出成绩最高的学生并输出其学号
void max(Student* stu, int size) {
    int index_max_score = 0; // 用于保存成绩最高学生的索引

    // 遍历数组，找出成绩最高的学生
    for (int i = 1; i < size; ++i) {
        if (stu[i].score > stu[index_max_score].score) {
            index_max_score = i; // 更新成绩最高的学生索引
        }
    }

    // 输出成绩最高学生的学号
    std::cout << "成绩最高的学生学号是：" << stu[index_max_score].student_id << std::endl;
}

int main() {
    // 创建一个包含5个学生数据的数组
    Student students[5] = {
        Student("S001", 90.5),
        Student("S002", 85.0),
        Student("S003", 92.5),
        Student("S004", 88.0),
        Student("S005", 91.0)
    };

    // 调用max函数，传入学生数组和数组大小
    max(students, 5);

    return 0;
}

代码分析2

在这个程序中，我们首先定义了一个学生类Student，每个学生有一个学号student_id和一个成绩score。然后我们定义了一个函数max，它接受一个指向Student对象数组的指针stu和数组的大小size。函数max遍历数组，找出成绩最高的学生，并通过他们的学号输出。

在main函数中，我们创建了一个Student对象数组students，并初始化了5个学生的数据。然后我们调用max函数，并传入students数组以及数组的大小（这里是5）。

3.类student，包含三个数据成员english，math，chinese，其中chinese是静态成员。以及一个show函数，显示其数据成员的值

（1）建立student构造函数，对数据成员进行赋值
（2）动态创建对象，并利用delete释放
（3）建立友元函数disPrivate，用于在类外输出student类的数据成员

参考代码3

#include <iostream>

class Student {
private:
    float english;
    float math;
    static float chinese; // 静态成员变量

public:
    // 构造函数
    Student(float eng, float ma, float chi) : english(eng), math(ma) {
        // 由于chinese是静态变量，所有对象共享，因此可能不在此处设置
        chinese = chi;
    }

    // 显示数据成员的值
    void show() const {
        std::cout << "英语成绩：" << english
                  << "，数学成绩：" << math
                  << "，语文成绩：" << chinese << std::endl;
    }

    // 声明友元函数
    friend void disPrivate(Student& stu);
};

// 初始化静态成员变量
float Student::chinese = 0;

// 友元函数实现
void disPrivate(Student& stu) {
    std::cout << "英语成绩：" << stu.english
              << "，数学成绩：" << stu.math
              << "，语文成绩：" << Student::chinese << std::endl;
}

int main() {
    // 动态创建对象
    Student* studentPtr = new Student(85.5, 93.0, 88.0);

    // 使用对象指针调用成员函数show显示成绩
    studentPtr->show();

    // 使用友元函数输出Student类的数据成员
    disPrivate(*studentPtr);

    // 删除动态创建的对象
    delete studentPtr;
    studentPtr = nullptr; // 为了安全，将指针设置为nullptr

    return 0;
}

代码分析3

在这段代码中：

Student 类包含了两个普通数据成员 english 和 math，以及一个静态数据成员 chinese。
Student 的构造函数接受三个参数来初始化对象，并设置静态成员 chinese。
show 成员函数用来显示学生的英语、数学和语文成绩。
disPrivate 是一个友元函数，它可以访问Student类的私有成员和静态成员，用于在类外部输出学生的成绩信息。
在 main 函数中，我们动态创建了一个 Student 类的对象，并利用 new 分配内存。使用该对象调用 show 方法和 disPrivate 函数来显示数据，然后使用 delete 释放动态分配的内存。
请注意，静态成员变量 chinese 是类的所有实例共享的，所以对它的任何修改都会反映在所有实例上。此外，在 delete 对象后将指针设置为 nullptr 是一个好习惯，以避免悬挂指针导致的未定义行为。