È un buon progetto memorizzare il tipo di oggetto nella classe base come enum? Ad esempio, considera la seguente gerarchia
Expr
--Unary
--Binary
--Const
----Int
----Float
Come rappresentare la gerarchia di cui sopra in C ++, in modo da poter esaminare il tipo di oggetto di una sottoclasse.
enum ExprType {
Const, Binary, Unary
};
class Expr {
ExprType type;
public:
Expr(ExprType t) : type(t) { }
ExprType GetType() { return type; }
};
class BinNode: public Expr {
Expr* left, *right;
Operator op;
public:
BinNode() : Expr(ExprType::Binary) { }
};
class UnrNode: public Expr {
Expr* operand;
Operator op;
public:
UnrNode() : Expr(ExprType::Unary) { }
};
enum ConstNodeType {
Int, Float
};
class ConstNode: public Expr {
ConstNodeType cntype;
public:
ConstNode(ConstNodeType t) : Expr(ExprType::Const), cntype(t) { }
ConstNodeType GetConstType() { return cntype; }
};
class IntNode: public ConstNode {
int value;
public:
IntNode() : ConstNode(ConstNodeType::Int) { }
};
class FloatNode: public ConstNode {
float value;
public:
FloatNode() : ConstNode(ConstNodeType::Float) { }
};
Ora posso fare,
Expr* node = new IntNode();
node->GetType(); // returns ExprType::Const
node->GetConstType(); // return ConstNodeType::Int
Questo è un buon modo idiomatico per creare una gerarchia di classi? Praticamente voglio controllare il tipo di un oggetto di qualsiasi sottoclasse di Expr .
Posso farlo in C # usando l'operatore is senza un membro di tipo speciale.
Expr node = new IntNode();
assert(node is ConstNode);
assert(node is IntNode);
In C ++, posso usare RTTI, ma è questo il modo idiomatico di creare una classe di gerarchie? Esiste un modo alternativo per esprimere la stessa gerarchia?