代码实现智能图书管理系统

Python代码实现智能图书管理系统

下面是一个简单的智能图书管理系统的 Python 实现，包括多个模块。该系统具有基本的图书管理功能，包括添加图书、借阅图书、归还图书和显示图书列表等。我们将系统分为以下模块：

book.py：包含 Book 类，用于表示图书对象。 library.py：包含 Library 类，用于管理图书库和相关操作。 user.py：包含 User 类，用于表示系统用户，并实现借阅和归还图书的功能。 main.py：包含程序入口点，用于用户与系统交互。 现在，让我们逐个模块来实现：

book.py 模块

class Book:
    def __init__(self, title, author):
        self.title = title
        self.author = author
        self.is_available = True

    def __str__(self):
        return f"Title: {self.title}, Author: {self.author}, Available: {self.is_available}"

library.py 模块

from book import Book

class Library:
    def __init__(self):
        self.books = []

    def add_book(self, book):
        self.books.append(book)

    def display_books(self):
        for book in self.books:
            print(book)

    def find_book(self, title):
        for book in self.books:
            if book.title == title:
                return book
        return None

user.py 模块

from book import Book

class User:
    def __init__(self, name):
        self.name = name
        self.borrowed_books = []

    def borrow_book(self, book):
        if book.is_available:
            book.is_available = False
            self.borrowed_books.append(book)
            print(f"{self.name} has borrowed '{book.title}'")
        else:
            print(f"{book.title} is not available for borrowing")

    def return_book(self, book):
        if book in self.borrowed_books:
            book.is_available = True
            self.borrowed_books.remove(book)
            print(f"{self.name} has returned '{book.title}'")
        else:
            print(f"{self.name} did not borrow '{book.title}'")

    def display_borrowed_books(self):
        if self.borrowed_books:
            print(f"{self.name}'s borrowed books:")
            for book in self.borrowed_books:
                print(book)
        else:
            print(f"{self.name} has not borrowed any books")

main.py 模块

这个智能图书管理系统具有基本的功能，并分为多个模块，使代码更具可读性和可维护性。通过这种方式，你可以根据需要对系统进行扩展和修改。

from library import Library
from user import User
from book import Book

def main():
    library = Library()

    # 添加一些图书到图书馆
    book1 = Book("The Great Gatsby", "F. Scott Fitzgerald")
    book2 = Book("To Kill a Mockingbird", "Harper Lee")
    book3 = Book("1984", "George Orwell")
    library.add_book(book1)
    library.add_book(book2)
    library.add_book(book3)

    # 创建用户并演示借书和还书功能
    user1 = User("Alice")
    user1.borrow_book(book1)
    user1.borrow_book(book2)
    user1.display_borrowed_books()

    user2 = User("Bob")
    user2.borrow_book(book1)  # 这本书已被借走，将会提示不可借
    user2.borrow_book(book3)
    user2.display_borrowed_books()

    user1.return_book(book1)
    user2.return_book(book3)
    user1.display_borrowed_books()
    user2.display_borrowed_books()

    # 显示所有图书
    library.display_books()

if __name__ == "__main__":
    main()

C++代码实现智能图书管理系统

系统设计思想

一个更复杂的 C++ 实现，并将其分为多个模块，然后将这些模块拼接在一起形成一个文件。我们将使用面向对象的设计思想，并尽可能使用类、继承、组合、封装等面向对象的特性来实现图书管理系统。

我们将系统划分为以下模块：

1. book.h 和 book.cpp：包含 Book 类，用于表示图书对象。
2. user.h 和 user.cpp：包含 User 类，用于表示系统用户，并实现借阅和归还图书的功能。
3. library.h 和 library.cpp：包含 Library 类，用于管理图书库和相关操作。
4. main.cpp：包含程序入口点，用于用户与系统交互。

book.h 和 book.cpp 模块：

// book.h
#ifndef BOOK_H
#define BOOK_H

#include <string>

class Book {
public:
    Book(const std::string& title, const std::string& author);
    std::string getTitle() const;
    std::string getAuthor() const;
    bool isAvailable() const;
    void setAvailable(bool available);

private:
    std::string title;
    std::string author;
    bool available;
};

#endif // BOOK_H

// book.cpp
#include "book.h"

Book::Book(const std::string& title, const std::string& author)
    : title(title), author(author), available(true) {}

std::string Book::getTitle() const {
    return title;
}

std::string Book::getAuthor() const {
    return author;
}

bool Book::isAvailable() const {
    return available;
}

void Book::setAvailable(bool available) {
    this->available = available;
}

user.h 和 user.cpp 模块

// user.h
#ifndef USER_H
#define USER_H

#include <string>
#include <vector>
#include "book.h"

class User {
public:
    User(const std::string& name);
    void borrowBook(Book& book);
    void returnBook(Book& book);
    void displayBorrowedBooks() const;

private:
    std::string name;
    std::vector<Book*> borrowedBooks;
};

#endif // USER_H

// user.cpp
#include "user.h"

User::User(const std::string& name)
    : name(name) {}

void User::borrowBook(Book& book) {
    if (book.isAvailable()) {
        book.setAvailable(false);
        borrowedBooks.push_back(&book);
        std::cout << name << " has borrowed '" << book.getTitle() << "'" << std::endl;
    } else {
        std::cout << book.getTitle() << " is not available for borrowing" << std::endl;
    }
}

void User::returnBook(Book& book) {
    auto it = std::find(borrowedBooks.begin(), borrowedBooks.end(), &book);
    if (it != borrowedBooks.end()) {
        book.setAvailable(true);
        borrowedBooks.erase(it);
        std::cout << name << " has returned '" << book.getTitle() << "'" << std::endl;
    } else {
        std::cout << name << " did not borrow '" << book.getTitle() << "'" << std::endl;
    }
}

void User::displayBorrowedBooks() const {
    if (!borrowedBooks.empty()) {
        std::cout << name << "'s borrowed books:" << std::endl;
        for (const auto& book : borrowedBooks) {
            std::cout << book->getTitle() << " by " << book->getAuthor() << std::endl;
        }
    } else {
        std::cout << name << " has not borrowed any books" << std::endl;
    }
}

library.h 和 library.cpp 模块

// library.h
#ifndef LIBRARY_H
#define LIBRARY_H

#include <vector>
#include "book.h"

class Library {
public:
    void addBook(const Book& book);
    void displayBooks() const;
    Book* findBook(const std::string& title);

private:
    std::vector<Book> books;
};

#endif // LIBRARY_H

// library.cpp
#include "library.h"

void Library::addBook(const Book& book) {
    books.push_back(book);
}

void Library::displayBooks() const {
    std::cout << "Books in the library:" << std::endl;
    for (const auto& book : books) {
        std::cout << book.getTitle() << " by " << book.getAuthor();
        if (book.isAvailable()) {
            std::cout << " (Available)" << std::endl;
        } else {
            std::cout << " (Not Available)" << std::endl;
        }
    }
}

Book* Library::findBook(const std::string& title) {
    for (auto& book : books) {
        if (book.getTitle() == title) {
            return &book;
        }
    }
    return nullptr;
}

main.cpp 模块

#include <iostream>
#include "book.h"
#include "user.h"
#include "library.h"

int main() {
    // 创建图书馆
    Library library;

    // 添加一些图书到图书馆
    Book book1("The Great Gatsby", "F. Scott Fitzgerald");
    Book book2("To Kill a Mockingbird", "Harper Lee");
    Book book3("1984", "George Orwell");
    library.addBook(book1);
    library.addBook(book2);
    library.addBook(book3);

    // 创建用户并演示借书和还书功能
    User user1("Alice");
    user1.borrowBook(book1);
    user1.borrowBook(book2);
    user1.displayBorrowedBooks();

    User user2("Bob");
    user2.borrowBook(book1);  // 这本书已被借走，将会提示不可借
    user2.borrowBook(book3);
    user2.displayBorrowedBooks();

    user1.returnBook(book1);
    user2.returnBook(book3);
    user1.displayBorrowedBooks();
    user2.displayBorrowedBooks();

    // 显示所有图书
    library.displayBooks();

    return 0;
}

这个实现中，我们使用了面向对象的设计思想，将系统分成了多个模块，每个模块负责不同的功能。通过类、成员函数、组合等技术，我们实现了一个复杂的图书管理系统。