C++电子词典程序 单词查询记忆功能

std::unordered_map

query <word>

add <word> <meaning>

review

Dictionary

Word

UserInterface

// 示例：Word结构体
#include <string>
#include <chrono> // 用于获取时间戳
#include <unordered_map>
#include <vector>
#include <fstream>
#include <iostream>

struct Word {
    std::string text;
    std::string meaning;
    std::string example; // 示例句子
    int queryCount;      // 查询次数
    long long lastQueryTime; // 上次查询的时间戳 (Unix timestamp)

    // 默认构造函数
    Word() : queryCount(0), lastQueryTime(0) {}

    // 带参数的构造函数
    Word(const std::string& t, const std::string& m, const std::string& e = "")
        : text(t), meaning(m), example(e), queryCount(0), lastQueryTime(0) {}
};

// 示例：Dictionary类核心
class Dictionary {
private:
    std::unordered_map<std::string, Word> words;
    std::string dataFilePath;

    // 获取当前时间戳
    long long getCurrentTimestamp() const {
        return std::chrono::duration_cast<std::chrono::seconds>(
            std::chrono::system_clock::now().time_since_epoch()).count();
    }

public:
    Dictionary(const std::string& path) : dataFilePath(path) {
        loadWords(); // 构造时加载
    }

    ~Dictionary() {
        saveWords(); // 析构时保存
    }

    void loadWords() {
        std::ifstream ifs(dataFilePath);
        if (!ifs.is_open()) {
            std::cerr << "Warning: Dictionary data file not found or cannot be opened. Starting with empty dictionary." << std::endl;
            return;
        }

        std::string line;
        while (std::getline(ifs, line)) {
            // 简单解析：text,meaning,example,queryCount,lastQueryTime
            size_t pos1 = line.find(',');
            size_t pos2 = line.find(',', pos1 + 1);
            size_t pos3 = line.find(',', pos2 + 1);
            size_t pos4 = line.find(',', pos3 + 1);

            if (pos1 == std::string::npos || pos2 == std::string::npos ||
                pos3 == std::string::npos || pos4 == std::string::npos) {
                std::cerr << "Warning: Malformed line in dictionary file: " << line << std::endl;
                continue;
            }

            Word word;
            word.text = line.substr(0, pos1);
            word.meaning = line.substr(pos1 + 1, pos2 - pos1 - 1);
            word.example = line.substr(pos2 + 1, pos3 - pos2 - 1);
            word.queryCount = std::stoi(line.substr(pos3 + 1, pos4 - pos3 - 1));
            word.lastQueryTime = std::stoll(line.substr(pos4 + 1));

            words[word.text] = word;
        }
        ifs.close();
    }

    void saveWords() {
        std::ofstream ofs(dataFilePath);
        if (!ofs.is_open()) {
            std::cerr << "Error: Cannot open dictionary data file for saving." << std::endl;
            return;
        }

        for (const auto& pair : words) {
            const Word& word = pair.second;
            ofs << word.text << ","
                << word.meaning << ","
                << word.example << ","
                << word.queryCount << ","
                << word.lastQueryTime << std::endl;
        }
        ofs.close();
    }

    Word* queryWord(const std::string& text) {
        auto it = words.find(text);
        if (it != words.end()) {
            // 更新查询统计
            it->second.queryCount++;
            it->second.lastQueryTime = getCurrentTimestamp();
            return &(it->second);
        }
        return nullptr;
    }

    bool addWord(const Word& newWord) {
        if (words.count(newWord.text) == 0) { // 避免重复添加
            words[newWord.text] = newWord;
            return true;
        }
        return false;
    }

    // 记忆功能相关方法，例如 getWordsForReview()
    std::vector<Word*> getWordsForReview(int maxWords = 10) {
        std::vector<Word*> candidates;
        long long currentTime = getCurrentTimestamp();
        long long oneDayInSeconds = 24 * 3600; // 24小时

        // 简单的复习逻辑：比如上次查询时间超过24小时，且查询次数不多
        for (auto& pair : words) {
            // 这是一个非常简化的判断，实际SRS会复杂得多
            // 如果上次查询时间超过1天，并且查询次数小于5次（假设生词）
            if (currentTime - pair.second.lastQueryTime > oneDayInSeconds && pair.second.queryCount < 5) {
                candidates.push_back(&(pair.second));
            }
            if (candidates.size() >= maxWords) { // 限制复习单词数量
                break;
            }
        }
        // 实际应用中，可能会对candidates进行更复杂的排序或随机化
        return candidates;
    }
};

std::unordered_map

std::map

std::unordered_map

std::map

std::map

unordered_map

std::unordered_map