C++ Reflektion



  • Hallo Leute,

    ich muss ein Problem lösen. Die conditions müssen in Logikoperatoren umgewandelt und mit dem input Vektor verknüpft werden.

    Brauche das für eingelesene QT Elemente, die verknüpft werden sollen.

    Ich weiß in C++ gibt es keine Reflektion. Gibt es mittlerweile eine Möglichkeit das zu lösen?

    Am besten generisch, beliebig erweiterbar? Wie würde sowas aussehen?

    Danke euch.

    std::vector<bool> inputs = {true, false, true};
    std::vector<std::string> conditions = {"and", "or"};
    
    bool generateCondition()
    {
        bool returnValue = false;
        returnValue = inputs[0] conditions[0] inputs[1] conditions[1] inputs[2];
        return returnValue;
    }
    


  • Schreib einen Interpreter.



  • Hi,
    was auch geht ist das z.B:

    #include <iostream>
    #include <vector>
    enum OPERATOR{
        OR_OP,
        AND_OP
    };
    
    struct Input{
        bool value;
        Input(bool v): value(v){}
        [[nodiscard]] bool evaluate()const{
            return value;
        }
        Input& operator=(bool v){
            this->value = v;
            return *this;
        }
    };
    
    struct Condition{
    
        OPERATOR ops;
        Condition(OPERATOR op){
            this->ops= op;
    
        }
        bool evaluate(const Input &a,const Input & b)const{
            switch(this->ops){
                case OR_OP:
                    return a.evaluate() or b.evaluate();
                case AND_OP:
                    return a.evaluate() and b.evaluate();
    
            }
        }
    };
    
    bool evaluate(const std::vector<Condition> & conditions,const std::vector<Input> inputs){
        Input res = inputs[0];
        for(int i = 0; i<conditions.size(); i++){
            res = conditions[i].evaluate(res,inputs[i+1]);
        }
        return res.evaluate();
    }
    
    int main() {
        std::vector<Condition> condition ={OPERATOR::AND_OP,OPERATOR::AND_OP};
        std::vector<Input> inputs = {true,true,false};
    
        std::cout<<"Result is:"<<std::boolalpha<<evaluate(condition,inputs)<<std::endl;
        return 0;
    }
    

    Nicht der schönste Code aber klappt und kann man ausbauen wenn man möchte.
    P.S reflektions in Java oder C# zu verwenden ist in den meisten Fällen eher ein Design Fehler als wirklich von Nöten! ( Natürlich nicht immer)

    Grüße


Log in to reply