【问题标题】:Reading logical operators expression for truth table C++读取真值表 C++ 的逻辑运算符表达式
【发布时间】:2015-03-25 15:45:55
【问题描述】:

我正在尝试编写一个代码,该代码将采用格式类似于

的表达式
(((p∨q)∧((q→r)⊕(p∧r)))↔(r∧q))→(p∨r)

它需要为它打印出看起来像这样的真值表

p q r  (p V q)   (q→r) etc... until it gets to (((p∨q)∧((q→r)⊕(p∧r)))↔(r∧q))→(p∨r)
t t t     t         t    
t t f     t         f
t f t     t         t
t f f     t         t
f t t     t         t
f t f     t         f
f f t     f         t
f f f     f         t

我设计了一种处理 XOR 和隐含运算符的方法,但我意识到它仅在运算符位于内括号内时才有效,而不是当运算符位于两组括号之间时...

我已经为此工作了太多小时,有人可以告诉我我可以使用什么来代替吗?

现在我想多了,我可以尝试读取第一个 (),然后是第二个 () 等等作为单个变量,将它们转换为计算机可以理解的布尔值,然后将它们注入回去以正确的顺序转换成正确的格式?

我现在正在处理的源代码是

#include <iostream>
#include <iomanip>
#include <fstream>
#include <string>
#include <vector>
#include <algorithm>

int main()
{
    bool p[8] = { true, true, true, true, false, false, false, false };         // Declare the init T/F values
    bool q[8] = { true, true, false, false, true, true, false, false };
    bool r[8] = { true, false, true, false, true, false, true, false };

    std::string expression;                                     
    std::cout << "Enter expression (using ^ for AND, V for OR, X for XOR, and I for Implies (-->): \n";
    std::getline(std::cin, expression);


    int i = 0;
    int j = 0;
    std::vector<std::string> exprVector;
    for (std::string::iterator it = expression.begin; it != expression.end(); it++)
    {
        if (expression.at(i) == 'p')
        {
            exprVector[i] = "p[i]";
        }
        else if (expression.at(i) == 'q')
        {
            exprVector[i] = "q[i]";
        }
        else if (expression.at(i) == 'r')
        {
            exprVector[i] = "r[i]";
        }

        else if (expression.at(i) == '(')
        {
            exprVector[i] = "(";
        }
        else if (expression.at(i) == ')')
        {
            exprVector[i] = ") ";
        }
        else if (expression.at(i) == '^')
        {
            exprVector[i] = "&&";
        }
        else if (expression.at(i) == 'V')
        {
            exprVector[i] = "||";
        }
        else if (expression.at(i) == 'X')
        {
            char temp1;
            char temp2;
            i--;
            if (exprVector[i] == "p[i]")                                        // (p XOR q)
            {
                i++;
                i++;
                if (exprVector[i] == "q[i]")
                {

                    i--;
                    //clear vector[i] from exprVector
                    i--;
                    //clear vector[i] from exprVector

                    exprVector[i] = "((p[i] || q[i]) && ((p[i] && q[i]) == false))";

                }
                else if (exprVector[i] == "r")                                  // (p XOR r)
                {
                    i--;
                    //clear vector[i] from exprVector
                    i--;
                    //clear vector[i] from exprVector

                    exprVector[i] = "((p[i] || r[i]) && ((p[i] && r[i]) == false))";
                }
            }
            else if (exprVector[i] == "q")                                      // (q XOR p)
            {
                i++;
                i++;
                if (exprVector[i] == "p")
                {
                    i--;
                    //clear vector[i] from exprVector
                    i--;
                    //clear vector[i] from exprVector

                    exprVector[i] = "((q[i] || p[i]) && ((q[i] && p[i]) == false))";

                }
                else if (exprVector[i] == "r")                                  // (q XOR r)
                {
                    i--;
                    //clear vector[i] from exprVector
                    i--;
                    //clear vector[i] from exprVector

                    exprVector[i] = "((q[i] || r[i]) && ((q[i] && r[i]) == false))";
                }
            }
            else if (exprVector[i] == "r")                                      
            {
                i++;
                i++;
                if (exprVector[i] == "p")                                       // (r XOR p)
                {
                    i--;
                    //clear vector[i] from exprVector
                    i--;
                    //clear vector[i] from exprVector

                    exprVector[i] = "((r[i] || p[i]) && ((r[i] && p[i]) == false)";
                }
                if (exprVector[i] == "q")                                       // (r XOR q)
                {
                    i--;
                    //clear vector[i] from exprVector
                    i--;
                    //clear vector[i] from exprVector

                    exprVector[i] = "((r[i] || q[i]) && ((r[i] && q[i]) == false)";
                }
            }


        }
        else if (expression.at(i) == 'I')
        {
            if (exprVector[i] == "p[i]")                                        // (p ---> q)
            {
                i++;
                i++;
                if (exprVector[i] == "q[i]")
                {

                    i--;
                    //clear vector[i] from exprVector
                    i--;
                    //clear vector[i] from exprVector

                    exprVector[i] = "((p[i] == true) || (q[i] == false)";

                }
                else if (exprVector[i] == "r")                                  // (p ---> r)
                {
                    i--;
                    //clear vector[i] from exprVector
                    i--;
                    //clear vector[i] from exprVector

                    exprVector[i] = "((p[i] == true) || (r[i] == false)";
                }
            }
            else if (exprVector[i] == "q")                                      // (q ---> p)
            {
                i++;
                i++;
                if (exprVector[i] == "p")
                {
                    i--;
                    //clear vector[i] from exprVector
                    i--;
                    //clear vector[i] from exprVector

                    exprVector[i] = "((q[i] == true) || (p[i] == false))";

                }
                else if (exprVector[i] == "r")                                  // (q ---> r)
                {
                    i--;
                    //clear vector[i] from exprVector
                    i--;
                    //clear vector[i] from exprVector

                    exprVector[i] = "((q[i] == true) || (r[i] == false))";
                }
            }
            else if (exprVector[i] == "r")
            {
                i++;
                i++;
                if (exprVector[i] == "p")                                       // (r ---> p)
                {
                    i--;
                    //clear vector[i] from exprVector
                    i--;
                    //clear vector[i] from exprVector

                    exprVector[i] = "((r[i] == true) || (p[i] == false))";
                }
                if (exprVector[i] == "q")                                       // (r ---> q)
                {
                    i--;
                    //clear vector[i] from exprVector
                    i--;
                    //clear vector[i] from exprVector

                    exprVector[i] = "((r[i] == true) || (q[i] == false))";
                }

        }
        else if (expression.at(i) == '!')
        {
            i++
            if (exprVector[i] == "p")
            {
                //clear vector[i] from exprVector
                i--;
                //clear vector[i] from exprVector
                exprVector[i] == "(p[i] == false)"
            }
            if (exprVector[i] == "q")
            {
                //clear vector[i] from exprVector
                i--;
                //clear vector[i] from exprVector
                exprVector[i] == "(p[i] == false)"
            }
            if (exprVector[i] == "r")
            {
                //clear vector[i] from exprVector
                i--;
                //clear vector[i] from exprVector
                exprVector[i] == "(p[i] == false)"
            }

        }
        else if (expression.at(i) == ' ')
        {
        }

        i++;
        j++;

    }

}

【问题讨论】:

  • 你有没有考虑过类似数据结构的东西,它给你一棵树,允许你在每个节点上调用 print/eval。每个节点要么是您的变量之一,要么是具有子节点的运算符。
  • 我想先这样做,但我不知道如何处理括号..

标签: c++ boolean operators parentheses truthtable


【解决方案1】:

您是否考虑过递归下降解析器? http://en.wikipedia.org/wiki/Recursive_descent_parser

可能是某种其他类型的解析实现。然后您可以生成一个表示表达式的树,然后您可以针对所有可能的输入评估该树。

【讨论】:

  • 如果您按任何顺序输入输入,这会起作用吗?或者只有在格式相同时才有效 ((( ∨ )∧(( → )⊕( ∧ )))↔( ∧ ))→( ∨ )
  • 这是一种接受任何类型表达式的通用方法,以便可以以编程方式表示和评估它们。
  • 只是想更好地理解它.. 但是当我们在我的 pre-req C++ 课程中没有做类似的事情时,它似乎有点复杂,而我目前的课程是离散数学跨度>
猜你喜欢
  • 2013-09-06
  • 2023-01-23
  • 2012-11-17
  • 1970-01-01
  • 1970-01-01
  • 1970-01-01
  • 1970-01-01
  • 1970-01-01
  • 1970-01-01
相关资源
最近更新 更多