Re: inheritance, list of objects, polymorphism
On Dec 18, 11:43 pm, "io_x" <a...@b.c.invalid> wrote:
"James Kanze" <james.ka...@gmail.com> ha scritto nel
messaggionews:faa92180-c056-4080-87da-df0695a6af39@s20g2000yqd.googlegroups.com...
On Dec 17, 8:35 pm, "io_x" <a...@b.c.invalid> wrote:
"barbaros" <barba...@ptmat.fc.ul.pt> ha scritto nel
messaggionews:f2890a48-ed1d-4451-86e6-12c5fb13ccc5@a21g2000yqc.googlegroups.com...
i not understand much but this seems ok
No it's not. Not from a design point, anyway, and it doesn't begin to
fulfill the requirements.
What he basically needs is something along the lines of:
// Interface...
class Expression
{
Expression( Expression const& );
Expression& operator=( Expression const& );
public:
virtual ~Expression() {}
virtual double value() const = 0;
// other functions...?
};
so what there is in the class "Expression" there are only
functions or there is something, a pointer, a string type, a
double etc at last some data
There's nothing. Not even the functions. It's an interface;
you never instantiate it.
Error E2251 str0.cpp 24: Cannot find default constructor to initialize base
class 'Express
ion' in function OneOperandExpression::OneOperandExpression(const Expression *)
I say, "something like". I typed the code in off the top of my
head. I forgot that yes, since you've declared a constructor
(the copy constructor), you no longer get the default
constructor. So you have to provide it as well (protected, and
with an empty body).
Error E2034 str0.cpp 36: Cannot convert 'const Expression *' to 'Expression *'
in function
TwoOperandExpression::TwoOperandExpression(const Expression *,const Expression
*)
A simple typo. There's a const missing somewhere.
Error E2034 str0.cpp 37: Cannot convert 'const Expression *' to 'Expression *'
in function
TwoOperandExpression::TwoOperandExpression(const Expression *,const Expression
*)
Error E2251 str0.cpp 38: Cannot find default constructor to initialize base
class 'Express
ion' in function TwoOperandExpression::TwoOperandExpression(const Expression
*,const Expre
ssion *)
Error E2251 str0.cpp 54: Cannot find default constructor to initialize base
class 'Express
ion' in function ConstantExpression::ConstantExpression(double)
Error E2451 str0.cpp 86: Undefined symbol 'lhs' in function
AddExpression::value() const
Error E2451 str0.cpp 86: Undefined symbol 'rhs' in function
AddExpression::value() const
*** 7 errors in Compile ***
this is what seems at last compile
but i'm sure it not like or i don't like it
#include <iostream.h>
#include <list.h>
#include <string.h>
#include <stdlib.h>
using namespace std;
// Interface...
class Expression{
public:
Expression( ){st="";}
Expression( Expression& m){st=m.st;}
Expression& operator=( Expression& m )
{ st=m.st; return m;}
Copy construction and assignment were private for a reason. And
not implemented for the same reason.
double f(Expression& m){return atof(m.st.c_str());}
double value(){return f(*this);}
~Expression() {}
string st;
};
What is the string there for? Why are any of the constructors
public? Just add an empty default constructor (protected,
although it doesn't really matter).
And the whole point is that value is a pure virtual function
here.
class OneOperandExpression
{public:
OneOperandExpression(){m_op=0;}
OneOperandExpression(Expression* op){m_op=op;}
Why the assignments? Use initialization (as I initially did).
Expression* m_op;
And make this a pointer to const. If I can trust your error
messages, that's all that's required.
};
class TwoOperandExpression{
public:
TwoOperandExpression(Expression* lhs, Expression* rhs )
{ m_lhs = lhs; m_rhs=rhs;}
Expression* m_lhs;
Expression* m_rhs;
As above: use initialization, and make the members pointer to
const.
};
class ConstantExpression{
public:
ConstantExpression(double value){ m_value=value;}
virtual double value() {return m_value;}
double m_value;
Here, m_value should be private.
};
class NegExpression : public OneOperandExpression{
public:
NegExpression(){OneOperandExpression();}
What on earth are you doing here? First, it makes no sense for
NegExpression to have a default constructor, since a negation
operator always has an operand. And what is the purpose of
creating the temporary OneOperandExpression in the constructor
(which wouldn't have been possible with my code, since
OneOperandExpression was an abstract type).
NegExpression(Expression* op){m_op=op;}
double value(){return -(m_op->value());}
};
class AddExpression : public TwoOperandExpression{
public:
AddExpression(Expression* lhs, Expression* rhs )
:TwoOperandExpression( lhs, rhs ){;}
double value()
{return m_lhs->value()+m_rhs->value();}
};
You seem to put in the virtual keyword more or less at random.
int main(void)
{
return 0;
}
Somehow, I don't think you've understood what is going on.
--
James Kanze