inheritance, list of objects, polymorphism

Hello everybody,

I need help with an inheritance issue. I am implementing a sort of
symbolic calculus code. By the way, is the site www.ginac.de closed ?
Where can I find a mirror ?

Back to my code. I have a base class "Expression" and derived classes
"ExpressionSum", "ExpressionProduct", "ExpressionPower" and so on. For
instance, xy+yz+z is an ExpressionSum of two ExpressionProduct and an
Expression. The class ExpressionSum is implemented as a list of terms
to sum up. These terms should be any other Expressions (Products,
Powers, or mere Expressions). The problem is, when I call
ExpressionSum::add(expr), expr being an ExpressionProduct, it looks
like expr is first converted to a mere Expression and then added to
the list. This is different from what I want. I want a list of
Expressions, some of which should behave like Products, other like
Powers, etc.

I hope I made myself clear. I include below a small piece of code.
Thank you. Cristian Barbarosie http://cmaf.ptmat.fc.ul.pt/~barbaros/

#include <iostream>
#include <list>
using namespace std;

class Expression {
public:
  string nname;
  Expression ()
  { cout << "constructor Expression, no name provided" << endl;}
  Expression (string n)
  { cout << "constructor Expression, name " << n << endl;
    nname = n; }
  virtual string name()
  { cout << "method Expression::name"<< endl; return nname; }
};

class ExpressionProduct : public Expression {
public:
  list<Expression> factors;
  ExpressionProduct ()
  {cout << "constructor ExpressionProduct, no arguments" << endl;}
  ExpressionProduct (const Expression &f)
  { cout << "constructor ExpressionProduct, one argument" << endl;
    factors.push_back(f); }
  ExpressionProduct (const Expression &f, const Expression &g)
  { cout << "constructor ExpressionProduct, two arguments" << endl;
    factors.push_back(f);
    factors.push_back(g); }
  string name()
  { cout << "method ExpressionProduct::name"<< endl;
    list<Expression>::iterator i=factors.begin();
    if (i==factors.end()) return "1";
    string n;
    for (;i!=factors.end();i++) n = n + i->name();
    return n; }
};

class ExpressionSum : public Expression {
public:
  list<Expression> terms;
  ExpressionSum ()
  {cout << "constructor ExpressionSum, no arguments" << endl;}
  void add (Expression &m)
  { cout << "adding" << endl; terms.push_back(m); }
  string name()
  { cout << "method ExpressionSum::name"<< endl;
    list<Expression>::iterator i=terms.begin();
    if (i==terms.end()) return "0";
    string n=i->name();
    i++ ;
    for (;i!=terms.end();i++)
      n = n + '+' + i->name();
    return n; }
};

int main () {
  Expression x("x"), y("y"), z("z");
  ExpressionProduct xy(x,y), yz(y,z);
  cout << xy.name() << endl;
  ExpressionSum p;
  p.add(xy); p.add(yz); p.add(z);
  cout << p.name() << endl;
}