20170218C++项目班02_01Node实现

Node实现：

1：在方法后面加上override代表这个方法是重写的。
2：面向对象和使用对象：
    面向对象：对象语义，是浅拷贝的实现方式，实际只有一个对象，不支持拷贝。
    使用对象：值语义，实现了深拷贝的称之为值语义，因为实现了多个，拷贝后与原对象无关。
    注意：两种语义没有好坏之分，根据我们的工程和实际情况来定是对象语义和值语义。
3：我们每个Node都是单一的，应该是对象语义，不支持拷贝的。所以我们应该把赋值函数（op=）和拷贝构造函数干掉。
4：左右节点的生命周期应该是由上一个节点来管理。
5：实现对象语义一种方式是将类的赋值函数和拷贝构造函数做成私有的，另一种方式是使用抽象类来做：
    当哪一个类需要实现对象语义的时候就可以private继承于下面的类：

class NonCopyable//对象语义是拿来限制的
{
protected:
NonCopyable(){}
private:
NonCopyable(const NonCopyable&);
const NonCopyable& operator=(const NonCopyable&) = delete;
};

注意：使用public继承也是可以的，但是这个类并没有实现他，相当于是一个接口，对这种接口类的集成，我们一般使用private继承。原理来自于：
    以前学的可以知道一个类在自己没实现方法的时候默认会生出八个默认的函数（构造、析构、赋值、拷贝构造、op*、op&、const op*、const op&），如果本类没有实现这里面的某些方法且在对象生成的时候会现调用基类的对应方法，这里调用不到，所以防止了被拷贝构造和赋值。如果派生类实现了对应的方法，就不会调用基类的方法了，也做不了对象语义。
6：对象语义还可以通过智能指针的方式来做，例如再使用STL的时候，STL必须支持拷贝，释放时机变得不同，通过计数的方式来决定。

代码：

Node.h------------------------------------------------------------------------------------------------

#ifndef _NODE_H_
#define _NODE_H_
#include <cfloat>
#include <iostream>

namespace PoEdu
{
class NonCopyable//对象语义是拿来限制的不产生拷贝。对象语义还可以用智能指针的方式来实现。STL的时候
{
protected:
NonCopyable(){}
private:
NonCopyable(const NonCopyable&){ std::cout << "NonCopyable(NonCopyable&)" << std::endl; }
const NonCopyable& operator=(const NonCopyable&) = delete;//等于删除，不写=delete也可以，方便程序阅读。
};
class Node:public NonCopyable//对象语义的实现。
{
public:
Node(){}
virtual ~Node(){}
virtual double Calc() const = 0;
};

class NumberNode :public Node
{
public:
NumberNode(const double number) :num_(number){}
double Calc() const override//override告诉程序员这个方法是重写的
{
return num_;
}
private:
double num_;
};

class BinaryNode :public Node
{
public:
BinaryNode(Node* left, Node* right) :left_(left), right_(right)
{
}
~BinaryNode()
{
delete left_;
delete right_;
std::cout << "delete_lr" << std::endl;
}
protected:
Node* left_;//父类指针可以指向子类对象。
Node* right_;
};

class AddNode :public BinaryNode
{
public:
AddNode(Node* left, Node* right) :BinaryNode(left, right)
{
}
double Calc() const override
{
return left_->Calc() + right_->Calc();
}
};

class SubNode :public BinaryNode
{
public:
SubNode(Node* left, Node*right) :BinaryNode(left, right)
{
}
double Calc() const override
{
return left_->Calc() - right_->Calc();
}
};

class MulitplyNode :public BinaryNode
{
public:
MulitplyNode(Node* left, Node*right) :BinaryNode(left, right)
{
}
double Calc() const override
{
return left_->Calc() * right_->Calc();
}
};

class DivideNode :public BinaryNode
{
public:
DivideNode(Node* left, Node*right) :BinaryNode(left, right)
{
}
double Calc() const override
{
double divisor = right_->Calc();
if (divisor > DBL_EPSILON || divisor < -DBL_EPSILON)
{
divisor = left_->Calc() / right_->Calc();
}
return divisor;
}
};

class UnaryNode :public Node
{
public:
UnaryNode(Node* child) :child_(child){}
~UnaryNode()
{
delete child_;
std::cout << "delete_c" << std::endl;
}
protected:
Node* child_;
};

class MinusNode :UnaryNode
{
MinusNode(Node *child) :UnaryNode(child)
{
}
double Calc() const override
{
return -child_->Calc();
}
};
}
#endif

main.c-------------------------------------------------------------------------------------------------

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

int main()
{
using namespace PoEdu;
Node *p = new NumberNode(10);
Node *p1 = new NumberNode(20);
Node *p2 = new NumberNode(30);
Node *calc = new AddNode(p, new MulitplyNode(p1, p2));
std::cout << calc->Calc() << std::endl;

return 0;
}