From: "Michael Schuster" <Schuster AT eev DOT e-technik DOT uni-erlangen DOT de>
Organization: LS f. Elektr. Energieversorgung
To: djgpp AT delorie DOT com
Date: Thu, 19 Dec 1996 08:26:35 MEZ
Subject: C++ crashes with compiler error
Message-Id: <E9B8461726@merlin2.e-technik.uni-erlangen.de>

Hi 

I'm working with Djgpp v2.01, libgpp 2721.

I `ve written a C++ programm which you can see at the end of the
Mail (my comments are in German, never thought send it to s.o. else)

when compiling I get the errors:

am.cc:23: Internal compiler error.
am.cc:23: Please submit a full bug report to
`bug-g++@prep.ai.mit.edu'.

I reportet it to bug-g++ but noone answered and I don't know where to 
find a newsgroup to read about that.
Perhaps s.o. can give me hand, what I can do with such a problem?
Is there any mistake in my code causing the error?
Is it only the version of the libgpp or whatever?

Here the c++ code of am.cc:


#include <stream.h>
#include <stdio.h>
#include <math.h>

template <class T> class element
     {
      private:
       enum typ
   { unspezifisch, konstant, funktion, invers
   } art;
 // typ: 0 nur deklariert, noch nicht naeher spezifiziert
 // typ: 1 Konstante
 // typ: 2 Funktion f(x)
 // typ: 3 1/f(x)

 T a_co;
 T (*a_func) (T xa);

      public:
        element(const char) 
 // falls noch unbestimmt, immer mit Konstante initialisieren
 // Notwendig wenn nur Deklariert wird
   { art=unspezifisch;
     a_co=0;
     a_func=NULL;
     }

 element (T co) // Konstruktor aufruf fuer Konstanten
   {  art=konstant;
      a_co=co;
      a_func=NULL;
   }

 element(T (*func)(T) ) // Konstruktor fuer Funktionen
   { 
      art=funktion;
      a_func = func;
      a_co=0;
      }		      
        element(const element& temp) // Copykonstruktor
   { 
      a_co=temp.a_co;
      a_func=temp.a_func;
      art=temp.art;
   }

 int typ()
 // Fuer die Ueberpruefung des Typen ausserhalb der Klasse
   { switch (art)
        {
  case unspezifisch:
    return 0;
  case konstant:
    return 1;
  case funktion:
    return 2;
  case invers:
    return 3;

        }
   };
 T invers_a_func(T x)
   {
      return 1/a_func(x);
   }
 element& operator =(element& temp) 
 // Zuweisungskonstruktor element = element
   {if (this !=&temp)
        {  a_co=temp.a_co;
    a_func=temp.a_func;
    art=temp.art;
        }
      return *this;  
   }

 element& operator= (T ini) 
 //Zuweisungskonstruktor element = T
   {
      art=konstant;
      a_co=ini;
      return *this;
   }

        element& operator= (T (*ini)(T)) 
 //Zuweisungskonstruktor element = funktion (x)
   {  art=funktion;
      a_func=ini;
      return *this;
   }



      operator T()  
 //Evaluierung T= element
   { 
      switch (art)
        { 
  case unspezifisch:
      {
         cerr<<"Nicht initialisiert";
         return 0;
      }
  case konstant:
    return a_co;
  default:
      {
         cerr<<"Element ist Funktion und keine Konstante";
         return 0;
      }
        };
   }
 T operator() (T x)
 //Evaluierung T= element(x)
   {	     
      switch (art)
        { 
  case unspezifisch:
      {
         cerr<<"Nicht initialisiert";
         return 0;
      }
  case konstant:
    return a_co;
  case funktion:
    return a_func(x);
  case invers:
    return invers_a_func(x);
        };
   }

 element invert(void)
   {
      switch (art)
        { 
  case unspezifisch:
    cerr<<"  Nicht initialisiertes Element kann nicht invertiert
    werden"; art= unspezifisch; break;
  case konstant:
    a_co=1/a_co;
    break;

  case funktion:
    // Achtung die Ausgangsfunktion darf nicht destruiert werden,
    sonst Fehler art=invers; break;
  case invers:
    // Achtung das Ausgangselement darf nicht destruiert werden, sonst
    Fehler art=funktion;
        };

      return *this;
   };
     };
template <class T> element<T> invers (element<T> temp)
     {
 return temp.invert();
     };

// Fuer die Ausgabe 

template <class T> ostream& operator<<(ostream& s,element<T> temp)
   {
      switch(temp.typ())
        { 
  case 0:
    return s <<"Nicht initialisiert";
  default:
    return s<<double(temp);
        };
   }

//
// Vektoren
//
//

struct dimension
     { 
       int x;
       int y;
     };

template <class T> class vektor
     {
      public:
 dimension di; // nur fuer externe Zwecke bestimmt
      private:
 int n; // intern fuer die Vektordimension
 element<T> *el;
 void init()
   {
      di.x=n;
      di.y=1;
   }
      public:
 vektor(int ni)
 // Initialsierung mit  vektor (9) = Deklartion w,hrend Laufzeit
   {  
      n=ni;
      el=new element<T>[n+1](char(0));
      init();
   }
 vektor( const vektor& temp)
 // Copykonstruktor 
   {
      el=new element<T>[temp.n+1](char(0));
      n=temp.n;

      for (int z=0;z<n+1;z++)
        el[z]=temp.el[z];
      init();
   }
 ~vektor () 
   { delete[] el;
   }

 element<T>& operator[](const int i)
 // Fuer die Indizierung vektor[i]
   {
     return el[i];
   }
 vektor& operator=(vektor& temp)
   {
      if (this!= &temp)
        {
    delete[] el;
    n=temp.n;
    el=new element<T>[temp.n+1](char(0));

    for (int z=0;z<n+1;z++)
      el[z]=temp.el[z];
    init();
        };
      return *this;
   }
     };

// 
//
// Matrizen
//
//

template <class T> class matrix
     { 
      public:
 dimension di;
      private:  
 int n_; //Zeile
 int m_; //Spalte
 vektor<T> *zeile;
 void init()
   {
      di.x=n_; //Zeile
      di.y=m_; //Spalte
   }

      public:

 matrix (int x,int y)
        {
   zeile =new vektor<T>[x+1](y);
   n_=x; m_=y;
   init();
        }
 matrix (const matrix<T> &temp)
 // Copykonstruktor 
   {
      zeile =new vektor<T>[temp.n_+1](temp.m_);
      n_=temp.n_;
      m_=temp.m_;
      for (int z=0;z<n_+1;z++)
        zeile[z]=temp.zeile[z]; 
      // nur die Vektoren muessen neu beschrieben werden
      init();
   }


 ~matrix() 
   {
      delete[] zeile;
   }  

 vektor<T>& operator[](const int x)
   {
      return zeile[x];
   }

 matrix& operator=(matrix<T>& temp)
   {
      if (this!= &temp)
        {
    delete[] zeile;
    zeile =new vektor<T>[temp.n_+1](temp.m_);
    n_=temp.n_;
    m_=temp.m_;
    for (int z=0;z<n_+1;z++)
      zeile[z]=temp.zeile[z]; 
    // nur die Vektoren muessen neu beschrieben werden
    init();
        };
      return *this;
   }
     };
//
//
//  Funktionen fuer Matrizen & Vektoren
//
//

template <class T> dimension dim(const vektor<T>& temp)
     {
 return temp.di;
     }
template <class T> dimension dim(const matrix<T>& temp)
     {
       return temp.di;
    }
ostream& operator<<(ostream& s,dimension temp)
   {
      return s <<"\n X-dim:\t"<<temp.x<<"\n Y-dim:\t"<<temp.y;
         }

//
//
// Nur zu Debug-Zwecken
//
//

double dff(double x)
   {
      return sin(x);
   }

int main (void)
     {  double s=34.4;
 double c,d,e;


// Einzelelemente

 // Initialisierung
 element<double> a1=s; // Initialisierung wie double
        element<double> a2 =&dff;    // Initialisierung mit Funktion
 element<double> a3=a2;      // Initialisiernung mit element
        element<double> a4=1/a1;
        element<double> a5=invers(a2);

        //Umdefinition  
 a2=s; // Umdefinition auf Konstante;
 a1=&dff; // Umdefinition auf Funktion;

        //Ausgabe

 cout<<"\n **** Einzelemente ****";
 cout<<"\n Konstante \t" <<a2<<"\n Initialisiert mit \t"<< s<<"\n";
        cout<<"\n Funktion \t" <<a1(s)<<"\n Initialisiert mit \t"<<
        dff(s)<<"\n";
 cout<<"\n Inverse Konstante \t" <<a4<<"\n Initialisiert mit \t"<<
 1/s<<"\n";
        cout<<"\n Inverse Funktion \t" <<a5(s)<<"\n Initialisiert mit
        \t"<<1/dff(s)<<"\n";


// Vektoren

 vektor<double> v(9); //10er vektor
        vektor<double> t(2);
 vektor<double> de=v; // Zuweisung per Vektor
 // Initialisierung der einzelnen Elemente

 v[0]=s; //zuweisung an element 0;
 v[1]=v[0];
 v[2]=s;

 //Umdefinition
 v[0]=&dff;


 //Ausgabe
 cout<<"\n\n ***** Vektoren *****";
 cout <<"\n v";
 cout<<"\n Konstante \t" <<v[2]<<"\n Initialisiert mit \t"<< s<<"\n";
        cout<<"\n Funktion \t" <<v[0](s)<<"\n Initialisiert mit \t"<<
        dff(s)<<"\n";

 // Zuweisung anderer Vektoren
 cout <<"\n t=v";
 t=v;
 cout<<"\n Konstante \t" <<t[2]<<"\n Initialisiert mit \t"<< s<<"\n";
        cout<<"\n Funktion \t" <<t[0](s)<<"\n Initialisiert mit \t"<<
        dff(s)<<"\n";

 // Dimension:
 cout<<" \n Dimension von v";
 cout<<dim(v);

 cout<<" \n Dimension von t";
 cout<<dim(t);

// Matrizen
 //Initialisierung;

 matrix<double> m(19,19);
 m[19][19]=s;
 m[2][1]=&dff;
        matrix<double> m2=m;

 //Ausgabe
 cout<<"\n\n ***** Matrizen *****";
 cout <<"\n m2";
 cout<<"\n Konstante \t" <<m[19][19]<<"\n Initialisiert mit \t"<<
 s<<"\n";
        cout<<"\n Funktion \t" <<m2[2][1](s)<<"\n Initialisiert mit
        \t"<< dff(s)<<"\n";

    }

















**********************************************
Michael Schuster
E-mail: Schuster AT eev DOT e-technik DOT uni-erlangen DOT de

Universitaet Erlangen/Nuernberg
Lehrstuhl fuer Elektrische Energieversorgung
Cauerstrasse 4
91058 Erlangen

http://www.eev.e-technik.uni-erlangen.de/
**********************************************