我的逻辑类

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);
	}
}