这是我们课设目前的代码，接下来还需要：数据持久化
实现CSV读写
添加错误处理
设计数据验证，这些应该如何实现
// DateTime
.h
#pragma once
#include <string>
#include <ctime>
#include <sstream>
#include <iomanip>
#include <iostream>
// 日期类
class Date {
private:
int year, month, day;
public:
Date(int y = 0, int m = 0, int d = 0)
: year(y), month(m), day(d) {}
static Date fromString(const std::string& str) {
if (str
.empty()) return Date();
int y, m, d;
char delim;
std::stringstream ss(str);
ss >> y >> delim >> m >> delim >> d;
return Date(y, m, d);
}
std::string toString() const {
std::stringstream ss;
ss << std::setfill('0') << std::setw(4) << year << "-"
<< std::setw(2) << month << "-" << std::setw(2) << day;
return ss
.str();
}
bool operator==(const Date& other) const {
return year == other
.year &&
month == other
.month &&
day == other
.day;
}
bool operator<(const Date& other) const {
if (year != other
.year) return year < other
.year;
if (month != other
.month) return month < other
.month;
return day < other
.day;
}
// 修复了 operator> 的实现
bool operator>(const Date& other) const {
if (year != other
.year) return year > other
.year;
if (month != other
.month) return month > other
.month;
return day > other
.day;
}
};
// 时间类
class Time {
private:
int hour, minute;
public:
Time(int h = 0, int m = 0) : hour(h), minute(m) {}
static Time fromString(const std::string& str) {
if (str
.empty()) return Time();
int h, m;
char delim;
std::stringstream ss(str);
ss >> h >> delim >> m;
return Time(h, m);
}
std::string toString() const {
std::stringstream ss;
ss << std::setfill('0') << std::setw(2) << hour << ":"
<< std::setw(2) << minute;
return ss
.str();
}
int toMinutes() const { return hour * 60 + minute; }
bool operator==(const Time& other) const {
return hour == other
.hour && minute == other
.minute;
}
bool operator<(const Time& other) const {
return toMinutes() < other
.toMinutes();
}
bool operator>(const Time& other) const {
return toMinutes() > other
.toMinutes();
}
};
// 时间段类
class TimeRange {
private:
Time start, end;
public:
TimeRange(const Time& s = Time(), const Time& e = Time())
: start(s), end(e) {}
static TimeRange fromString(const std::string& str) {
if (str
.empty()) return TimeRange();
size_t pos = str
.find('-');
if (pos == std::string::npos) return TimeRange();
return TimeRange(
Time::fromString(str
.substr(0, pos)),
Time::fromString(str
.substr(pos + 1))
);
}
std::string toString() const {
return start
.toString() + "-" + end
.toString();
}
bool overlaps(const TimeRange& other) const {
return start < other
.end&& end > other
.start;
}
// 添加相等运算符重载
bool operator==(const TimeRange& other) const {
return start == other
.start && end == other
.end;
}
};
// 考试时间段
class
ExamSlot {
private:
Date date;
TimeRange time;
public:
ExamSlot(const Date& d = Date(), const TimeRange& t = TimeRange())
: date(d), time(t) {}
static
ExamSlot fromString(const std::string& str) {
if (str
.empty()) return
ExamSlot();
size_t pos = str
.find(' ');
if (pos == std::string::npos) return
ExamSlot();
return
ExamSlot(
Date::fromString(str
.substr(0, pos)),
TimeRange::fromString(str
.substr(pos + 1))
);
}
std::string toString() const {
return date
.toString() + " " + time
.toString();
}
bool conflictsWith(const
ExamSlot& other) const {
return date == other
.date && time
.overlaps(other
.time);
}
// 添加相等运算符重载（修复了编译错误）
bool operator==(const
ExamSlot& other) const {
return date == other
.date && time == other
.time;
}
};
// Teacher
.h
#include <vector>
#include <string>
#include <algorithm>
class Teacher {
private:
std::string id;
std::string name;
std::vector<
ExamSlot> assignedSlots;
public:
Teacher(const std::string& id = "", const std::string& name = "")
: id(id), name(name) {}
// 访问器
const std::string& getId() const { return id; }
const std::string& getName() const { return name; }
// 添加清除监考任务的方法
void clearAssignments() {
assignedSlots
.clear();
}
// 添加监考任务
void assignExam(const
ExamSlot& slot) {
if (std::find(assignedSlots
.begin(), assignedSlots
.end(), slot) == assignedSlots
.end()) {
assignedSlots
.push_back(slot);
}
}
// 检查时间段是否可用
bool isAvailable(const
ExamSlot& slot) const {
for (const auto& assigned : assignedSlots) {
if (assigned
.conflictsWith(slot)) {
return false;
}
}
return true;
}
// 统计监考次数
int totalProctorCount() const {
return static_cast<int>(assignedSlots
.size());
}
// 序列化
std::string toString() const {
return id + "," + name + "," + std::to_string(totalProctorCount());
}
};
// Exam
.h
#include <vector>
#include <string>
#include <algorithm>
class Exam {
private:
std::string courseCode;
std::string courseName;
ExamSlot slot;
std::string location;
int studentCount;
std::vector<std::string> instructors;
std::vector<std::string> proctors;
public:
Exam(const std::string& code = "", const std::string& name = "",
const
ExamSlot& slot =
ExamSlot(), const std::string& loc = "",
int students = 0)
: courseCode(code), courseName(name), slot(slot),
location(loc), studentCount(students) {}
// 访问器
const std::string& getCourseCode() const { return courseCode; }
const std::string& getCourseName() const { return courseName; }
const
ExamSlot& getSlot() const { return slot; }
const std::string& getLocation() const { return location; }
int getStudentCount() const { return studentCount; }
// 添加清除监考教师的方法
void clearProctors() {
proctors
.clear();
}
// 教师管理
void addInstructor(const std::string& teacher) {
if (std::find(instructors
.begin(), instructors
.end(), teacher) == instructors
.end()) {
instructors
.push_back(teacher);
}
}
void addProctor(const std::string& teacher) {
if (std::find(proctors
.begin(), proctors
.end(), teacher) == proctors
.end()) {
proctors
.push_back(teacher);
}
}
const std::vector<std::string>& getInstructors() const { return instructors; }
const std::vector<std::string>& getProctors() const { return proctors; }
// 检查教师身份
bool isInstructor(const std::string& teacher) const {
return std::find(instructors
.begin(), instructors
.end(), teacher) != instructors
.end();
}
// 计算所需监考人数
int requiredProctors() const {
return studentCount > 50 ? 3 : 2;
}
// 当前监考人数
int currentProctors() const {
return static_cast<int>(proctors
.size());
}
// 序列化
std::string toString() const {
std::string result = courseCode + "," + courseName + "," +
slot
.toString() + "," + location + "," +
std::to_string(studentCount) + ",";
// 添加任课教师
for (size_t i = 0; i < instructors
.size(); ++i) {
if (i > 0) result += ";";
result += instructors[i];
}
result += ",";
// 添加监考教师
for (size_t i = 0; i < proctors
.size(); ++i) {
if (i > 0) result += ";";
result += proctors[i];
}
return result;
}
// 反序列化
static Exam fromString(const std::string& str) {
std::vector<std::string> parts;
std::stringstream ss(str);
std::string item;
while (std::getline(ss, item, ',')) {
parts
.push_back(item);
}
if (parts
.size() < 7) return Exam();
Exam exam(
parts[0],
parts[1],
ExamSlot::fromString(parts[2]),
parts[3],
std::stoi(parts[4])
);
// 解析任课教师
std::stringstream instructorsStream(parts[5]);
while (std::getline(instructorsStream, item, ';')) {
if (!item
.empty()) exam
.addInstructor(item);
}
// 解析监考教师
std::stringstream proctorsStream(parts[6]);
while (std::getline(proctorsStream, item, ';')) {
if (!item
.empty()) exam
.addProctor(item);
}
return exam;
}
};
// ProctorAssigner
.h
#include <vector>
#include <algorithm>
#include <random>
#include <unordered_map>
#include <climits>
class ProctorAssigner {
public:
// 执行监考分配
void assign(std::vector<Exam>&
exams, std::vector<Teacher>& teachers) {
// 1
. 按时间排序考试
std::sort(
exams.begin(),
exams.end(), [](const Exam& a, const Exam& b) {
return a
.getSlot()
.toString() < b
.getSlot()
.toString();
});
// 2
. 重置所有监考分配
for (auto& teacher : teachers) {
teacher
.clearAssignments(); // 使用新添加的方法
}
for (auto& exam :
exams) {
exam
.clearProctors(); // 使用新添加的方法
}
// 3
. 准备教师映射
std::unordered_map<std::string, Teacher*> teacherMap;
for (auto& teacher : teachers) {
teacherMap[teacher
.getName()] = &teacher;
}
// 4
. 分配任课教师
assignInstructors(
exams, teacherMap);
// 5
. 分配额外监考
assignAdditionalProctors(
exams, teachers);
}
private:
// 分配任课教师
void assignInstructors(std::vector<Exam>&
exams,
std::unordered_map<std::string, Teacher*>& teacherMap) {
for (auto& exam :
exams) {
for (const auto& instructor : exam
.getInstructors()) {
auto it = teacherMap
.find(instructor);
if (it != teacherMap
.end()) {
Teacher* teacher = it->second;
if (teacher->isAvailable(exam
.getSlot())) {
exam
.addProctor(instructor);
teacher->assignExam(exam
.getSlot());
}
}
}
}
}
// 分配额外监考
void assignAdditionalProctors(std::vector<Exam>&
exams,
std::vector<Teacher>& teachers) {
// 创建随机数生成器
static std::mt19937 rng(std::random_device{}());
for (auto& exam :
exams) {
int needed = exam
.requiredProctors() - exam
.currentProctors();
while (needed > 0) {
// 随机打乱教师顺序以确保均衡性
std::shuffle(teachers
.begin(), teachers
.end(), rng);
Teacher* bestCandidate = nullptr;
int minAssignments = INT_MAX;
// 寻找最合适的教师
for (auto& teacher : teachers) {
// 跳过任课教师
if (exam
.isInstructor(teacher
.getName())) continue;
// 检查时间冲突
if (!teacher
.isAvailable(exam
.getSlot())) continue;
// 选择监考次数最少的教师
if (teacher
.totalProctorCount() < minAssignments) {
minAssignments = teacher
.totalProctorCount();
bestCandidate = &teacher;
}
}
// 如果没有可用教师，退出循环
if (!bestCandidate) break;
// 分配监考
exam
.addProctor(bestCandidate->getName());
bestCandidate->assignExam(exam
.getSlot());
needed--;
}
}
}
};
// CsvHandler
.h
#include <fstream>
#include <sstream>
#include <vector>
#include <string>
class CsvHandler {
public:
// 加载考试数据
static std::vector<Exam> load
Exams(const std::string& filePath) {
std::vector<Exam>
exams;
std::ifstream file(filePath);
if (!file
.is_open()) {
return
exams;
}
std::string line;
std::getline(file, line); // 跳过标题行
while (std::getline(file, line)) {
if (line
.empty()) continue;
Exam exam = Exam::fromString(line);
if (!exam
.getCourseCode()
.empty()) {
exams.push_back(exam);
}
}
file
.close();
return
exams;
}
// 加载教师数据
static std::vector<Teacher> loadTeachers(const std::string& filePath) {
std::vector<Teacher> teachers;
std::ifstream file(filePath);
if (!file
.is_open()) {
return teachers;
}
std::string line;
std::getline(file, line); // 跳过标题行
while (std::getline(file, line)) {
if (line
.empty()) continue;
std::stringstream ss(line);
std::string id, name;
std::getline(ss, id, ',');
std::getline(ss, name);
if (!id
.empty() && !name
.empty()) {
teachers
.push_back(Teacher(id, name));
}
}
file
.close();
return teachers;
}
// 保存考试数据
static bool save
Exams(const std::vector<Exam>&
exams, const std::string& filePath) {
std::ofstream file(filePath);
if (!file
.is_open()) {
return false;
}
// 标题行
file << "课程代码,课程名称,考试时间,地点,学生人数,任课教师,监考教师\n";
for (const auto& exam :
exams) {
file << exam
.toString() << "\n";
}
file
.close();
return true;
}
// 保存统计数据
static bool saveStatistics(const std::vector<Teacher>& teachers, const std::string& filePath) {
std::ofstream file(filePath);
if (!file
.is_open()) {
return false;
}
// 标题行
file << "教师ID,教师姓名,总监考次数\n";
for (const auto& teacher : teachers) {
file << teacher
.toString() << "\n";
}
file
.close();
return true;
}
};
// main
.cpp
int main() {
try {
// 1
. 加载数据
auto
exams = CsvHandler::load
Exams("all_
exams.csv");
auto teachers = CsvHandler::loadTeachers("teachers
.csv");
// 2
. 筛选本系考试
std::string department = "计算机科学与技术系";
std::vector<Exam> dept
Exams;
for (const auto& exam :
exams) {
// 根据实际数据结构实现筛选逻辑
// 示例：if (exam
.getDepartment() == department)
...
dept
Exams.push_back(exam);
}
// 3
. 执行监考分配
ProctorAssigner assigner;
assigner
.assign(dept
Exams, teachers);
// 4
. 保存结果
CsvHandler::save
Exams(dept
Exams, "dept_
exams.csv");
CsvHandler::saveStatistics(teachers, "statistics
.csv");
std::cout << "监考分配完成！结果已保存到文件。" << std::endl;
}
catch (const std::exception& e) {
std::cerr << "发生错误: " << e
.what() << std::endl;
return 1;
}
return 0;
}
扫一扫
196
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
