[comp.lang.c++] Multiple inheritance example stops Zortech 2.0 C++ compiler

charlie@genrad.com (Charlie D. Havener) (01/02/90)

// Zortech 2.0 bug with multiple inheritance
// compiler says ztc Bug 9513 and stops
// Walter, what is code 9513? Is there a work around?
// The Sun 2.0 C++ compiles and runs it OK
// charlie Havener GenRad Inc. 508-369-4400 x3302
// charlie@genrad.com
// This example is a part of an Abstract Syntax Tree
// as described in Dewhurst and Stark book

#include <stream.h>
#include <stdlib.h>


//---------------- Data Related classes follow -----

union Value
    {
    int ival;
    double rval;
    };

enum DataType { INT, REAL, UNKNOWN };

// class Node;    // a forward declaration DOESN'T WORK!
// for class Data : public Node with Data eval()

class Data  // an abstract class
    {
protected:
    Data() {}  // for 1.2 C++ to prevent instantiation
    // should make pure virtual funcs below in C++ 2.0
public:
    Value x;  // had to make public so derived class mfuncs
		// could access it
    virtual DataType GetType() const { return UNKNOWN; }
    virtual ~Data() {}
    virtual Data operator+(const Data&);
    virtual Data eval() { cerr << "Data eval() base class\n"; return *this;}
    };
    
class Int : public Data
    {
public:
    Int(int t) { x.ival = t; }
    // no dtor needed since ctor didn't use new
    DataType GetType() const { return INT; }
    Data eval() { return *this; }
    Data operator+(const Data&);
    };
    
class Real : public Data
    {
public:
    Real(double t) { x.rval = t; }
    // no dtor needed since ctor didn't use new
    DataType GetType() const { return REAL; }
    Data eval() { return *this; }
    Data operator+(const Data&);
    };

// -------------  Parse tree nodes ----------------
class Node
    {
protected:
    Node(){}
public:
    virtual ~Node() {}
    virtual Data eval() {Real x(0.0); cerr << "In Node virtual eval()"; return x;}
    virtual void print() { cerr << "No print() defined\n"; }
    };

class Binop : public Node
    {
protected:
    Node *left;
    Node *right;
    Binop(Node *l,Node *r) { left = l; right = r;}
    ~Binop() { delete left; delete right; }
    };

class Plus : public Binop
    {
public:
    Plus(Node *l,Node *r) : (l,r) {};
    Data eval() { return ( left->eval() + right->eval()); }
    };
//------------------------------------

class IntVal : public Node , public Data
    {
    Int t;
public:
    IntVal(Int &p) : t(p) { }
    };

main()
    {
    Real x(0.0);
    Int k(0);
    IntVal iv(k);
    IntVal rv(k);
    Node *np = new Plus(&iv,&rv);

    cout << "Hello world\n";
    np->print();
    }

//-------------- implementation -----------------

Data Int::operator+(const Data& y)
    {
    if ( y.GetType() == INT )
	{
	Int result(x.ival + y.x.ival);
	return result;
	}
    else if ( y.GetType() == REAL )
	{
	Real result(x.ival + y.x.rval);
	return result;
	}
    else
	{
	cerr << "unknown rhs type in int'+' operator \n";
	exit(1);
	}
    }

Data Real::operator+(const Data& y)
    {
    if ( y.GetType() == INT )
	{
	Real result(x.rval + y.x.ival);
	return result;
	}
    else if ( y.GetType() == REAL )
	{
	Real result(x.rval + y.x.rval);
	return result;
	}
    else
	{
	cerr << "unknown rhs type in real '+' operator \n";
	exit(1);
	}
    }

Data Data::operator+(const Data&)
    { cerr << "virtual Data::operator+()!!!\n"; exit(1); }