Cacher is the code snippet organizer for pro developers

#include <iostream>

/**
 * prototype for evaluatable tree
 */

enum EvalType {
	EvalType_Int,
	EvalType_Add
};
/* Base eval class
 * has a type and a result node.
 * the result node carries the last evaluatable result 
 */
class EvalNode
{
public:
	EvalNode(): _result(nullptr) {}
	~EvalNode() { delete _result; }


	EvalType getType() const {
		return _type;
	}
	void setType(EvalType type) {
		_type = type;
	}

	const EvalNode* getResult() const {
		return _result;
	}

	void delResult() {
		delete _result;
		_result = nullptr;
	}

	bool hasResult() const { return _result != nullptr; }

	/**
	 * this resets the result node based off the 
	 * child node values.
	 */
	virtual void eval() const {
		_result = this;
	}
private:
	EvalNode* _result;
	EvalType _type;
};

/**
 * class to represent int
 */
class IntNode : public EvalNode
{
public:
	IntNode(int value = 0): _value(value) {
		setType(EvalType_Int);
	}
	~IntNode(){}

	int getValue() const { return _value; }
	void setValue(int val) { _value = val; }
private:
	int _value;
};

class AddNode : public EvalNode
{
public:
	AddNode(int lfs, int rfs):
	       _lfs(new IntNode(lfs)),
	       _rfs(new IntNode(rfs))
	       {
	       	  setType(EvalType_Add);
	       }
	AddNode(EvalNode* lfs = nullptr, EvalNode* rfs = nullptr):
	        _lfs(lfs), _rfs(rfs)
	        {
	        	setType(EvalType_Add);
	        }
	~AddNode() {
		delete _lfs;
		delete _rfs;
	}

	void eval() const {
		if(_lfs != nullptr)
			_lfs.eval();
		if(_rfs != nullptr)
			_rfs.eval();
		IntNode* ilfs = dynamic_cast<IntNode*>(_lfs);
		IntNode* irfs = dynamic_cast<IntNode*>(_rfs);
		if(hasResult()) {
			delResult();
		}
		_result = new IntNode(ilfs.getValue() + irfs.getValue());
	}
private:
	EvalNode* _lfs;
	EvalNode* _rfs;
};



int main(int argc, char const* argv[]) {
	std::cout << "Hello World!\n";
}