面向对象表达式

表达式计算器设计

STARTUML选择抽象类 字体变为斜体

类图：

注：（BinaryNode应该也是虚类）

如果多了一元运算节点呢：

这时候继承体系应该是

简单代码：

Node.h:

#ifndef _NODE_H_
#define _NODE_H_

class Node
{
public:
	virtual double Calc() const = 0;
	virtual ~Node() {};
};

class NumberNode : public Node
{
public:
	NumberNode(double number) : number_(number) {}
	double Calc() const;
private:
	const double number_;
};

class BinaryNode : public Node
{
public:
	BinaryNode(Node* left, Node* right)
		: left_(left), right_(right) {}
	~BinaryNode();
protected:
	Node* const left_;
	Node* const right_;
};

class UnaryNode : public Node
{
public:
	UnaryNode(Node* child)
		: child_(child) {}
	~UnaryNode();
protected:
	Node* const child_;
};

class AddNode : public BinaryNode
{
public:
	AddNode(Node* left, Node* right)
		: BinaryNode(left, right) {}
	double Calc() const;
};

class SubNode : public BinaryNode
{
public:
	SubNode(Node* left, Node* right)
		: BinaryNode(left, right) {}
	double Calc() const;
};

class MultiplyNode : public BinaryNode
{
public:
	MultiplyNode(Node* left, Node* right)
		: BinaryNode(left, right) {}
	double Calc() const;
};

class DivideNode : public BinaryNode
{
public:
	DivideNode(Node* left, Node* right)
		: BinaryNode(left, right) {}
	double Calc() const;
};

class UMinusNode : public UnaryNode
{
public:
	UMinusNode(Node* child)
		: UnaryNode(child) {}
	double Calc() const;
};

#endif // _NODE_H_

Node.cpp:

#include "Node.h"
#include <cmath>
#include <iostream>

double NumberNode::Calc() const
{
	return number_;
}

BinaryNode::~BinaryNode()
{
	delete left_;
	delete right_;
}

UnaryNode::~UnaryNode()
{

}

double AddNode::Calc() const
{
	return left_->Calc() + right_->Calc();
}

double SubNode::Calc() const
{
	return left_->Calc() - right_->Calc();
}

double MultiplyNode::Calc() const
{
	return left_->Calc() * right_->Calc();
}

double DivideNode::Calc() const
{
	double divisor = right_->Calc();
	if (divisor != 0.0)
		return left_->Calc() / divisor;
	else
	{
		std::cout<<"Error: Divisor by zero"<<std::endl;
		return HUGE_VAL;
	}
}

double UMinusNode::Calc() const
{
	return - child_->Calc();
}