代码编写一个课时记录系统

Python 代码编写一个课时记录系统

Course.py

class Course:
    def __init__(self, name, duration):
        self.name = name
        self.duration = duration

Student.py

class Student:
    def __init__(self, name):
        self.name = name
        self.attendance = 0

AttendanceSystem.py

class AttendanceSystem:
    def __init__(self):
        self.courses = []
        self.students = []

    def add_course(self, name, duration):
        if duration <= 0:
            raise ValueError("Duration should be a positive integer")
        course = Course(name, duration)
        self.courses.append(course)

    def add_student(self, name):
        student = Student(name)
        self.students.append(student)

    def mark_attendance(self, student_name, course_name):
        student = next((s for s in self.students if s.name == student_name), None)
        course = next((c for c in self.courses if c.name == course_name), None)
        if student is None or course is None:
            raise ValueError("Student or course not found")
        student.attendance += course.duration

main.py

from Course import Course
from Student import Student
from AttendanceSystem import AttendanceSystem

# 使用示例
attendance_system = AttendanceSystem()

try:
    attendance_system.add_course("Math", 3)
    attendance_system.add_course("Physics", -2)  # 引发异常
except ValueError as e:
    print("Error:", e)

attendance_system.add_student("Alice")
attendance_system.add_student("Bob")

try:
    attendance_system.mark_attendance("Alice", "Math")
    attendance_system.mark_attendance("Alice", "Chemistry")  # 引发异常
except ValueError as e:
    print("Error:", e)

C++ 代码编写一个课时记录系统

Course.h

#ifndef COURSE_H
#define COURSE_H

#include <string>

class Course {
public:
    Course(const std::string& name, int duration);
    std::string get_name() const;
    int get_duration() const;

private:
    std::string name;
    int duration;
};

#endif // COURSE_H

Course.cpp

#include "Course.h"

Course::Course(const std::string& name, int duration) : name(name), duration(duration) {}

std::string Course::get_name() const {
    return name;
}

int Course::get_duration() const {
    return duration;
}

Student.cpp

#include "Student.h"

Student::Student(const std::string& name) : name(name), attendance(0) {}

std::string Student::get_name() const {
    return name;
}

int Student::get_attendance() const {
    return attendance;
}

void Student::add_attendance(int duration) {
    attendance += duration;
}

AttendanceSystem.h

#ifndef ATTENDANCESYSTEM_H
#define ATTENDANCESYSTEM_H

#include <vector>
#include <stdexcept>
#include "Course.h"
#include "Student.h"

class AttendanceSystem {
public:
    void add_course(const std::string& name, int duration);
    void add_student(const std::string& name);
    void mark_attendance(const std::string& student_name, const std::string& course_name);

private:
    std::vector<Course> courses;
    std::vector<Student> students;
};

#endif // ATTENDANCESYSTEM_H

AttendanceSystem.cpp

#include "AttendanceSystem.h"

void AttendanceSystem::add_course(const std::string& name, int duration) {
    if (duration <= 0) {
        throw std::invalid_argument("Duration should be a positive integer");
    }
    courses.emplace_back(name, duration);
}

void AttendanceSystem::add_student(const std::string& name) {
    students.emplace_back(name);
}

void AttendanceSystem::mark_attendance(const std::string& student_name, const std::string& course_name) {
    auto student_it = std::find_if(students.begin(), students.end(), [&](const Student& s) {
        return s.get_name() == student_name;
    });
    auto course_it = std::find_if(courses.begin(), courses.end(), [&](const Course& c) {
        return c.get_name() == course_name;
    });
    if (student_it == students.end() || course_it == courses.end()) {
        throw std::invalid_argument("Student or course not found");
    }
    student_it->add_attendance(course_it->get_duration());
}

main.cpp

#include <iostream>
#include "AttendanceSystem.h"

int main() {
    AttendanceSystem attendance_system;

    try {
        attendance_system.add_course("Math", 3);
        attendance_system.add_course("Physics", -2); // 引发异常
    } catch (const std::invalid_argument& e) {
        std::cerr << "Error: " << e.what() << std::endl;
    }

    attendance_system.add_student("Alice");
    attendance_system.add_student("Bob");

    try {
        attendance_system.mark_attendance("Alice", "Math");
        attendance_system.mark_attendance("Alice", "Chemistry"); // 引发异常
    } catch (const std::invalid_argument& e) {
        std::cerr << "Error: " << e.what() << std::endl;
    }

    return 0;
}

Go 代码编写一个课时记录系统

package main

import (
	"errors"
	"fmt"
)

// Course 表示课程
type Course struct {
	name     string
	duration int
}

// Student 表示学生
type Student struct {
	name       string
	attendance int
}

// AttendanceSystem 表示课时记录系统
type AttendanceSystem struct {
	courses  []*Course
	students []*Student
}

// NewCourse 创建新的课程
func NewCourse(name string, duration int) (*Course, error) {
	if duration <= 0 {
		return nil, errors.New("Duration should be a positive integer")
	}
	return &Course{name: name, duration: duration}, nil
}

// NewStudent 创建新的学生
func NewStudent(name string) *Student {
	return &Student{name: name}
}

// AddCourse 添加课程
func (as *AttendanceSystem) AddCourse(course *Course) {
	as.courses = append(as.courses, course)
}

// AddStudent 添加学生
func (as *AttendanceSystem) AddStudent(student *Student) {
	as.students = append(as.students, student)
}

// MarkAttendance 标记出勤
func (as *AttendanceSystem) MarkAttendance(studentName, courseName string) error {
	var student *Student
	for _, s := range as.students {
		if s.name == studentName {
			student = s
			break
		}
	}
	if student == nil {
		return errors.New("Student not found")
	}
	var course *Course
	for _, c := range as.courses {
		if c.name == courseName {
			course = c
			break
		}
	}
	if course == nil {
		return errors.New("Course not found")
	}
	student.attendance += course.duration
	return nil
}

func main() {
	attendanceSystem := AttendanceSystem{}

	mathCourse, err := NewCourse("Math", 3)
	if err != nil {
		fmt.Println("Error:", err)
		return
	}
	physicsCourse, err := NewCourse("Physics", -2)
	if err != nil {
		fmt.Println("Error:", err)
		return
	}
	attendanceSystem.AddCourse(mathCourse)
	attendanceSystem.AddCourse(physicsCourse)

	alice := NewStudent("Alice")
	bob := NewStudent("Bob")
	attendanceSystem.AddStudent(alice)
	attendanceSystem.AddStudent(bob)

	err = attendanceSystem.MarkAttendance("Alice", "Math")
	if err != nil {
		fmt.Println("Error:", err)
		return
	}
	err = attendanceSystem.MarkAttendance("Alice", "Chemistry")
	if err != nil {
		fmt.Println("Error:", err)
		return
	}
}

这段代码实现了一个简单的课时记录系统，包括了课程、学生以及课时记录系统的功能。