突发奇想续

简单写了点代码，把那个方程组生成树结构：

#include <iostream>
#include <string>
using namespace std;


enum Type{
	TNumber,
	TVariable,
	TOperator
};

enum Operator{
	OAdd,
	OSub,
	OMul,
	ODiv,
	OAssign,
	ONone
};


class Variable{
	Type type_;
	const char* name_;
	Operator op_;
	double value_;
	Variable* var1_;
	Variable* var2_;

	public:
	template <class T>
	static Variable convertToVariable(T value){
		return Variable(static_cast<double>(value));
	}

	Variable(const char* name){
		type_ = TVariable;
		name_ = name;
		op_ = ONone;
		var1_ = 0;
		var2_ = 0;
	}

	Variable(const Variable& var){
		type_ = var.type_;
		name_ = var.name_;
		op_ = var.op_;
		value_ = var.value_;
		if (var.var1_) var1_ = new Variable(*var.var1_); else var1_ = 0;
		if (var.var2_) var2_ = new Variable(*var.var2_); else var2_ = 0;
	}

	Variable(double value){
		type_ = TNumber;
		value_ = value;
		op_ = ONone;
		var1_ = 0;
		var2_ = 0;
	}

	Variable(Operator op, Variable var1, Variable var2){
		type_ = TOperator;
		op_ = op;
		var1_ = new Variable(var1);
		var2_ = new Variable(var2);
	}

	~Variable(){
		if (type_ == TOperator){
			delete var1_;
			delete var2_;
		}
	}

	template <class T>
	Variable operator + (T value){
		return Variable(OAdd, *this, Variable::convertToVariable(value));
	}

	template <class T>
	Variable operator - (T value){
		return Variable(OSub, *this, Variable::convertToVariable(value));
	}

	template <class T>
	Variable operator * (T value){
		return Variable(OMul, *this, Variable::convertToVariable(value));
	}

	template <class T>
	Variable operator / (T value){
		return Variable(ODiv, *this, Variable::convertToVariable(value));
	}

	template <class T>
	Variable operator = (T value){
		return Variable(OAssign, *this, Variable::convertToVariable(value));
	}

	Variable operator = (Variable value){
		return Variable(OAssign, *this, value);
	}

	friend ostream& operator << (ostream& os, const Variable& var);
};



template <>
Variable Variable::convertToVariable<Variable>(Variable value){
	return Variable(value);
}

template <class T>
Variable operator + (T value, Variable var){
	return Variable(OAdd, Variable::convertToVariable(value), var);
}

template <class T>
Variable operator - (T value, Variable var){
	return Variable(OSub, Variable::convertToVariable(value), var);
}

template <class T>
Variable operator * (T value, Variable var){
	return Variable(OMul, Variable::convertToVariable(value), var);
}

template <class T>
Variable operator / (T value, Variable var){
	return Variable(ODiv, Variable::convertToVariable(value), var);
}

int deep = 0;
ostream& operator << (ostream& os, const Variable& var){
	for (int i=0; i<deep; ++i)
		os << "\t";

	os << "|";
	switch(var.type_){
	case TNumber:
		os << "Number: " << var.value_;
		break;
	case TOperator:
		os << "Operator: ";
		{
			switch(var.op_){
			case ODiv:
				os << "/";
				break;
			case OMul:
				os << "*";
				break;
			case OAdd:
				os << "+";
				break;
			case OSub:
				os << "-";
				break;
			case OAssign:
				os << "=";
				break;
			}
		}
		break;
	case TVariable:
		os << "Variable: " << string(var.name_);
		break;
	}
	os << "|" << endl;
	deep ++;
	if (var.var1_) os << *var.var1_;
	if (var.var2_) os << *var.var2_;
	deep --;
	return os;
}

int main(){
	Variable x("x");
	Variable y("y");

	// x = 10; y = 5;
	const Variable& v1 = (x + 5 = y * 3);
	const Variable& v2 = (x / y = 2);
	const Variable& v3 = ((x + y) * (x - y) / 5 = 15);

	cout << v1 << endl;
	cout << v2 << endl;
	cout << v3 << endl;
}

输出结果如下：

|Operator: =|
        |Operator: +|
                |Variable: x|
                |Number: 5|
        |Operator: *|
                |Variable: y|
                |Number: 3|

|Operator: =|
        |Operator: /|
                |Variable: x|
                |Variable: y|
        |Number: 2|

|Operator: =|
        |Operator: /|
                |Operator: *|
                        |Operator: +|
                                |Variable: x|
                                |Variable: y|
                        |Operator: -|
                                |Variable: x|
                                |Variable: y|
                |Number: 5|
        |Number: 15|

不过最外层的几个对象都是临时的，所以必须要在它们析构以前把预处理的结果存入x和y中。

另外由于C＋＋语言方面的原因，这里必须写成对象拷贝而不是引用或指针。

离最终结果还很遥远，一步步看吧。。。