Skip to content
The Chat Archive
chatgpt-4o-latest-20250326· OpenAI LMArena Human Preference 140K

У тебя получилось круто написать реферат. Только нужно представить твой последний пример…

  1. User

    У тебя получилось круто написать реферат. Только нужно представить твой последний пример с "Умным домом" в виде программы на С++

  2. Assistant

    Спасибо! Рад, что пример тебе понравился 😊

    Теперь давай реализуем паттерн "Интерпретатор" на языке C++, как в примере с "Умным домом". Мы опишем DSL (domain-specific language) для выполнения пользовательских условий вроде:

    температура > 25 И человек_в_комнате = да
    

    И разберем, как это интерпретируется через паттерн.


    🎯 Цель программы:

    Создать систему, которая:

    1. Хранит текущее состояние "умного дома".
    2. Позволяет описывать условия для его автоматизации.
    3. Интерпретирует эти условия и возвращает результат (true или false).

    🧠 Шаг 1: Определим структуру классов по паттерну "Интерпретатор"

    Абстрактный интерфейс выражения:

    class HomeState;
    
    class Expression {
    public:
        virtual ~Expression() = default;
        virtual bool interpret(const HomeState& state) const = 0;
    };
    

    🏡 Шаг 2: Контекст — Хранилище состояния дома

    #include <unordered_map>
    #include <string>
    
    class HomeState {
    public:
        std::unordered_map<std::string, double> numericSensors;
        std::unordered_map<std::string, bool> boolSensors;
    
        double getNumericValue(const std::string& name) const {
            auto it = numericSensors.find(name);
            return (it != numericSensors.end()) ? it->second : 0.0;
        }
    
        bool getBoolValue(const std::string& name) const {
            auto it = boolSensors.find(name);
            return (it != boolSensors.end()) ? it->second : false;
        }
    };
    

    🌱 Шаг 3: Терминальные выражения

    #include <memory>
    
    class NumericSensorExpression : public Expression {
        std::string sensorName;
    public:
        NumericSensorExpression(const std::string& name) : sensorName(name) {}
        bool interpret(const HomeState& state) const override {
            // Не возвращаем значение напрямую — используется в сравнении
            return true; // Заглушка
        }
    
        double getValue(const HomeState& state) const {
            return state.getNumericValue(sensorName);
        }
    };
    
    class BoolSensorExpression : public Expression {
        std::string sensorName;
    public:
        BoolSensorExpression(const std::string& name) : sensorName(name) {}
        bool interpret(const HomeState& state) const override {
            return state.getBoolValue(sensorName);
        }
    };
    
    class LiteralBoolExpression : public Expression {
        bool value;
    public:
        LiteralBoolExpression(bool val) : value(val) {}
        bool interpret(const HomeState&) const override {
            return value;
        }
    };
    
    class LiteralNumericExpression : public Expression {
        double value;
    public:
        LiteralNumericExpression(double val) : value(val) {}
        bool interpret(const HomeState&) const override {
            return true; // Не используется напрямую
        }
    
        double getValue() const {
            return value;
        }
    };
    

    ⚙️ Шаг 4: Нетерминальные выражения

    Сравнение чисел: >, = и т.д.

    class GreaterThanExpression : public Expression {
        std::shared_ptr<NumericSensorExpression> left;
        std::shared_ptr<LiteralNumericExpression> right;
    public:
        GreaterThanExpression(std::shared_ptr<NumericSensorExpression> l,
                              std::shared_ptr<LiteralNumericExpression> r)
            : left(l), right(r) {}
    
        bool interpret(const HomeState& state) const override {
            return left->getValue(state) > right->getValue();
        }
    };
    
    class EqualsBoolExpression : public Expression {
        std::shared_ptr<BoolSensorExpression> left;
        std::shared_ptr<LiteralBoolExpression> right;
    public:
        EqualsBoolExpression(std::shared_ptr<BoolSensorExpression> l,
                             std::shared_ptr<LiteralBoolExpression> r)
            : left(l), right(r) {}
    
        bool interpret(const HomeState& state) const override {
            return left->interpret(state) == right->interpret(state);
        }
    };
    

    Логические операции: И (AND), ИЛИ (OR)

    class AndExpression : public Expression {
        std::shared_ptr<Expression> left;
        std::shared_ptr<Expression> right;
    public:
        AndExpression(std::shared_ptr<Expression> l,
                      std::shared_ptr<Expression> r)
            : left(l), right(r) {}
    
        bool interpret(const HomeState& state) const override {
            return left->interpret(state) && right->interpret(state);
        }
    };
    

    ✔️ Шаг 5: Пример использования

    #include <iostream>
    
    int main() {
        // Состояние умного дома
        HomeState home;
        home.numericSensors["температура"] = 28.5;
        home.boolSensors["человек_в_комнате"] = true;
        
        // Создаем выражения:
        auto tempExpr = std::make_shared<NumericSensorExpression>("температура");
        auto tempLiteral = std::make_shared<LiteralNumericExpression>(25.0);
        auto condition1 = std::make_shared<GreaterThanExpression>(tempExpr, tempLiteral);
    
        auto boolExpr = std::make_shared<BoolSensorExpression>("человек_в_комнате");
        auto boolLiteral = std::make_shared<LiteralBoolExpression>(true);
        auto condition2 = std::make_shared<EqualsBoolExpression>(boolExpr, boolLiteral);
    
        // Объединение двух условий через И (AND)
        auto fullCondition = std::make_shared<AndExpression>(condition1, condition2);
    
        // Интерпретация — выполняем условие
        if (fullCondition->interpret(home)) {
            std::cout << "Условие выполнено: включить кондиционер! ❄️" << std::endl;
        } else {
            std::cout << "Условие НЕ выполнено: кондиционер выключен. 🔕" << std::endl;
        }
    
        return 0;
    }
    

    📌 Вывод программы

    Условие выполнено: включить кондиционер! ❄️
    

    Если изменить температуру на 22.0, программа напечатает:

    Условие НЕ выполнено: кондиционер выключен. 🔕
    

    🧩 Вывод и связь с теорией паттерна

    Элемент паттернаРеализация
    ContextHomeState
    AbstractExpressionИнтерфейс Expression
    TerminalExpressionBoolSensorExpression, Literal
    NonTerminalExpressionGreaterThanExpression, AndExpression
    Clientmain()

    📚 Дополнительно

    Ты можешь легко расширить:

    • поддржку выражений ИЛИ
    • переменные текстового типа (location == "кухня")
    • функции (время_суток() > 22)
    • «то» часть условий (экшенов), и система станет полноценной автоматизацией!

    Если ты вставишь это в C++ IDE — всё соберется из "коробки" (не забудь #include <memory>, #include <string>, #include <unordered_map>, #include <iostream>).

    Удачи с докладом! Если хочешь — могу помочь оформить это и в презентацию 🧑‍💻📊

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.