Ideas on class Parameter structure given implementation - c++

Question

Question simplified: an expression is a parameter. It includes 2 objects of type parameter. But, is that parameter a string_class, ID_class, or Expression_class parameter? If I just say Parameter, it won't have these certain characteristics, will it? How do I have these objects, use logic, and then I can know if the private data members of Expression are string, id, or expression parameters? Sometimes I want that left parameter to be an expression, sometimes I want it to be a string, sometimes an ID.
class Parameter
{
public:
private:
};
class String_class : public Parameter
{
public:
String_class(string in_string)
private:
string my_string;
};
class ID_class : public Parameter
{
public:
insert_id(string in_ID);
private:
string my_ID;
};
class Expression_class : public Parameter
{
private:
Parameter left_parameter;
Parameter right_parameter;
string op;
public:
};

Answer 1

Lots of ways to do this...
enum ParameterType{
PT_INVALID_TYPE = -1,
PT_OPERATION_TYPE= 0,
PT_STRING_TYPE,
PT_ID_TYPE,
PT_INT_TYPE,
...
PT_MAX_TYPES
}
class Parameter {
public:
...
virtual ParameterType GetType() = 0;
virtual string ToString() = 0; // GetValue(), etc...
}
class String_class : public Parameter
{
public:
String_class(string in_string){}
virtual ParameterType GetType() override { return PT_STRING_TYPE; }
virtual string ToString() override {return my_string;};
private:
string my_string;
};
class ID_class : public Parameter
{
public:
insert_id(string in_ID);
virtual ParameterType GetType() override { return PT_ID_TYPE; }
virtual string ToString() override {return my_ID;};
private:
string my_ID;
};
enum OperationType {
OP_INVALID_OP = -1,
OP_CONCATENATE = 0,
OP_ADD,
OP_COMPARE_EQUAL,
OP_COMPARE_LESS_THAN,
OP_XOR,
... // whatever
OP_MAX,
}
class Expression_class : public Parameter
{
private:
Parameter* left_parameter;
Parameter* right_parameter;
string op;
public:
};
Some usage examples...
class Expression_class : public Parameter
{
private:
Parameter* left_parameter;
Parameter* right_parameter;
string op;
public:
Expression_class(string _op, Parameter* lhs, Parameter* rhs):
left_parameter(lhs), right_parameter(rhs), op(_op)
{
// alternatively
left_parameter = lhs;
right_parameter = rhs;
op = _op;
}
~Expression_class(){
left_parameter = nullptr;
right_parameter = nullptr;
}
virtual ParameterType GetType() { return PT_OPERATION_TYPE; };
virtual string ToString() { return eval(); }
protected:
string eval() {
if(left_parameter.GetType() != PT_ID_TYPE) return "Invalid left_parameter.";
if(right_parameter.GetType() != PT_STRING_TYPE) return "Invalid right_parameter";
switch(op){ // op is better as OperationType than string
case OP_CONCATENATE : return left_parameter.ToString() + " " + right_parameter.ToString();
// ...
}
if(CompareNoCase(op, "+") == 0)
return left_parameter.ToString() + " " + right_parameter.ToString();
return "Invalid Opertaion";
}
};
String_class employee_name("Rick");
String_Id employee_id("007");
Expression_class exp(OP_CONCATENATE, &employee_id, employee_name);
return exp.ToString();
Notes This is not the only way to do it, and as you use your class, you'll figure out short cuts to do less work.