Puzzle

我的逻辑类

    A.第一版

    这个小程序是最初的版本。

    1。 程序基本说明：这是一个逻辑计算的类，我的思想是这个类可以成为一个判断的实例（proposition），将来通过De Morgen's Law来进行

    	逻辑计算，并有可能进行逻辑推理，例如，以前我做过的“爱因斯坦”的问题，也许就可以用这个类来做，（很乐观啊！哈哈）

    2。 程序思路：我的类为了将来的逻辑计算重载了很多操作符。

    	A. operator&& 逻辑与。

    	B. operator|| 逻辑或。

    	C. operator！ 逻辑非。

    	D. operator== 比较操作符，我是用内定的index来判断两个实例是否相同，这个值得推敲。

    	E. operator=  复制操作符。

    	F. bool state 逻辑类的逻辑状态，是核心数据。

    	G. char* express 逻辑类的名字。

    	H. static Logic* temp[100] 你想不出这个是干什么的吧？我确实没有什么好主意，在连续运算过程中，每次会返回一个新逻辑

    	类对象，这对于逻辑运算来说是一些中间过程对象，我把这些中间对象都存在这里，最后再全部释放。我不知道重定向（redirect)

    	是怎样实现的，对于那些运算他们是返回操作对象本身，这样就相当于赋值改变了对象的状态。例如：A||B&&C， 在A||B运算后必须

    	返回一个逻辑类对象N来进行"N&&C"的运算，而如果用A或者B做返回，就必须改变A或者B的状态，这不是我所要得。因此，我就产生

    	新的对象，如果，不在程序结束时消灭，会有很多问题。

    3。 主要函数介绍：

         A.  void catName(char*, const char*, LogicOp); 一个内部方法，主要是把两个对象的名字加上逻辑操作符合成新名字。我原

    	本用一个局域变量返回其指针，编译器总是报警，运行时候有很多莫名其妙的问题，最后，才明白要把buffer的指针传入。

    4。 不足之处：

    	A. 所有的操作符返回的是对象指针，很不好用，应该改为对象引用。

    	B. 我原本计划写一个检查方法，比如：假定A is true,然后检查A&&B||C的真假，但是，这很复杂，因为，第一，表达式可能不定长，

    	这等于我要写一个parser来翻译command命令，天啊！第二，很多对象的真假可能是不确定的，我只有一些所谓“规则”，按照这种

    	规则和有限的确定的量去进行推理，这种算法，我想可能还没有。

    #include <iostream>

    using namespace std;

    enum LogicOp
    {AND, OR, NOT, CONDITIONAL};

    char* OpStr[4] = {" AND ", " OR ", " NOT "," CONDITIONAL "};

    enum ELEMENT
    {R,S,I,W,D,H,F};

    char* factStr[7] =
    	{"It is raining", "It is snowing", "I get ill","I get wet", "I need doctor",
    	"It is hot", "I have a fevor"};

    class Logic
    {
    private:
    	static bool status;
    	static int logicCount;
    	char* express;
    	int index;
    	bool state;
    	void catName(char*, const char*, LogicOp);
    	static Logic* temp[100];
    	static int tempCount;
    	static Logic* TRUE;
    	static Logic* FALSE;
    	Logic* checkList[30];
    	bool definedStatus;
    protected:
    	void initialize();
    	bool compare(const Logic& dummy);
    	void uninitialize();
    public:
    	Logic(const char* newExpress, const bool value=false);
    	~Logic();
    	Logic();
    	bool getStatus() const {return definedStatus;}
    	void setStatus(const bool newStatus) {definedStatus = newStatus;}
    	void setExpress(const char*);
    	char* getExpress() const {return express;}
    	void setIndex(const int newIndex) { index = newIndex;}
    	int getIndex() const {return index;}
    	void setState(bool newState) { state = newState;}
    	bool getState() const{ return state;}
    	static const int count()  {return logicCount;}
    	Logic* operator&&(const Logic& dummy);
    	Logic* operator||(const Logic& dummy);
    	Logic* operator!();
    	bool operator==(const Logic& dummy);
    	Logic* operator&&(const bool value);
    	Logic* operator||(const bool value);
    	Logic* operator=(const Logic& dummy);
    	Logic* operator>>(const Logic& dummy);
    	void addRule(const Logic* rule);
    };

    Logic element[7];

    int main()
    {
    	Logic A("A"),B("B"), C("C");
    	Logic* ptr;

    	A.setState(true);
    	C.setState(true);
    	cout<<"A's state is:"<<(A.getState()?"true":"false")<<endl;
    	cout<<"B's state is:"<<(B.getState()?"true":"false")<<endl;
    	cout<<"C's state is:"<<(C.getState()?"true":"false")<<endl;
    	ptr = (*(A&&B))||C;

    	cout<<"now calculate (A&&B)||C which should be false now:"<<endl;
    	cout<<"the result name is:"<<ptr->getExpress()<<endl;
    	cout<<"the result is:"<<(ptr->getState()?"true":"false")<<endl;
    	cout<<"now set C to be false and calculate (A&&B)||C again, result should be false:"<<endl;
    	C.setState(false);
    	cout<<"A's state is:"<<(A.getState()?"true":"false")<<endl;
    	cout<<"B's state is:"<<(B.getState()?"true":"false")<<endl;
    	cout<<"C's state is:"<<(C.getState()?"true":"false")<<endl;

    	ptr = (*(A&&B))||C;

    	cout<<"the result name is:"<<ptr->getExpress()<<endl;
    	cout<<"the result is:"<<(ptr->getState()?"true":"false")<<endl;

    	return 0;
    }

    Logic* Logic::operator >>(const Logic& dummy)
    {
    	char buffer[256];
    	catName(buffer, dummy.getExpress(), CONDITIONAL);
    	temp[tempCount] = new Logic(buffer);

    	if (state&&(!dummy.getState()))
    	{
    		temp[tempCount]->setState(false);
    	}
    	else
    	{
    		temp[tempCount]->setState(true);
    	}
    	tempCount++;
    	return temp[tempCount-1];
    }

    void Logic::uninitialize()
    {
    	status = true;
    	for (int i=0; i< tempCount;i++)
    	{
    		delete temp[i];
    	}
    }

    bool Logic::status = false;

    Logic* Logic::temp[100] = {NULL};

    int Logic::tempCount = 0;

    Logic* Logic::FALSE = new Logic("FALSE", false);

    Logic* Logic::operator =(const Logic& dummy)
    {
    	setExpress(dummy.getExpress());
    	setState(dummy.getState());
    	return this;
    }

    Logic* Logic::TRUE = new Logic("TRUE", true);;

    Logic* Logic::operator &&(const bool value)
    {
    	if (value)
    	{
    		return (*this)&&(*TRUE);
    	}
    	else
    	{
    		return (*this)&&(*FALSE);
    	}
    }

    Logic* Logic::operator ||(const bool value)
    {
    	if (value)
    	{
    		return (*this)||(*TRUE);
    	}
    	else
    	{
    		return (*this)||(*FALSE);
    	}
    }

    bool Logic::operator ==(const Logic& dummy)
    {
    	return compare(dummy);
    }

    bool Logic::compare(const Logic& dummy)
    {
    	return (index==dummy.getIndex());
    }

    void Logic::catName(char* buffer, const char* second, LogicOp opcode)
    {
    	strcpy(buffer, getExpress());
    	strcat(buffer, OpStr[opcode]);
    	strcat(buffer, second);
    }

    Logic* Logic::operator !()
    {
    	char buffer[256];
    	strcpy(buffer, OpStr[NOT]);
    	strcat(buffer, getExpress());
    	temp[tempCount] = new Logic(buffer);
    	temp[tempCount]->setState(!getState());

    	tempCount++;
    	return temp[tempCount-1];
    }

    Logic* Logic::operator &&(const Logic& dummy)
    {
    	char buffer[256];
    	catName(buffer, dummy.getExpress(), AND);

    	temp[tempCount] = new Logic(buffer);
    	temp[tempCount]->setState(getState()&&dummy.getState());

    	tempCount++;
    	return temp[tempCount-1];
    }

    Logic* Logic::operator ||(const Logic& dummy)
    {
    	char buffer[256];
    	catName(buffer, dummy.getExpress(), OR);
    	temp[tempCount] = new Logic(buffer);
    	temp[tempCount]->setState(getState()||dummy.getState());

    	tempCount++;
    	return temp[tempCount-1];
    }

    int Logic::logicCount =0;

    void Logic::initialize()
    {
    	express = NULL;
    	state = false;
    	definedStatus = false;
    	setIndex(logicCount);
    	logicCount++;
    }

    Logic::~Logic()
    {
    	if (!status)  //if you destroy one, then you destroy all!!!!!
    	{
    		uninitialize();
    	}
    	if (express!=NULL)
    	{
    		free(express);
    	}
    }

    Logic::Logic(const char* newExpress, const bool value)
    {
    	initialize();
    	setExpress(newExpress);
    	setState(value);
    }

    Logic::Logic()
    {
    	initialize();
    }

    void Logic::setExpress(const char* newExpress)
    {

    	if (express==NULL)
    	{
    		int i;
    		i = strlen(newExpress) +1;
    		express = (char*)malloc(i);
    		strcpy(express, newExpress);
    	}
    }