Модель электронного устройства с использованием абстрактных классов

#include <iostream>
using namespace std;
 
typedef unsigned char Uchar;
typedef unsigned int Uint;
 
//---------------- class abstract ALU ------------------
 
class AbstractALU
{
public:
    AbstractALU(){}
    ~AbstractALU(){}
    virtual void calcRes()=0;
};
 
//---------------- class ALU ----------------------------------
 
class ALU : public AbstractALU
{
public:
    Uchar x1,x2,extIn;
    Uchar extOut,res;
 
    ALU();
    ALU( Uchar x1_, Uchar x2_, Uchar extIn_ );
    ~ALU(){};
    void setX1( Uchar x1_ ){ x1=x1_;}
    void setX2( Uchar x2_ ){ x2=x2_;}
    void setExtIn( Uchar extIn_ ){ extIn=extIn_;}
    Uchar getExtOut(){ return extOut;}
    Uchar getRes(){ return res;}
    void Display();
    
};
 
ALU::ALU()
{
    x1=0;
    x2=0;
    extIn=0;
}
 
ALU::ALU( Uchar x1_, Uchar x2_, Uchar extIn_ )
{
    x1=x1_;
    x2=x2_;
    extIn=extIn_;
}
 
void ALU::Display()
{
    cout << "Inputs: x1=" << (int)x1 << ", x2=" << (int)x2 << ", extIn=" << (int)extIn << endl;
    cout << "Outputs: extOut=" << (int)extOut << ", res=" << (int)res << endl;
}
 
//------------------------ class FA ----------------------
 
class FA : public ALU
{
public:
    FA();
    FA( Uchar x1_, Uchar x2_, Uchar extIn_);
    ~FA(){};
    void calcRes();
};
 
FA::FA()
{
    x1=0;
    x2=0;
    extIn=0;
}
 
FA::FA( Uchar x1_, Uchar x2_, Uchar extIn_) : ALU( x1_, x2_, extIn_)
{
    calcRes();
}
 
void FA::calcRes()
{
    res  = x1^x2^extIn;
    extOut = ( x1&x2 )| ( x1&extIn )|( x2&extIn ) ;
}
 
//-------------------------------- class FS -------------------------
 
class FS : public ALU
{
public:
    FS();
    FS( Uchar x1_, Uchar x2_, Uchar extIn_);
    ~FS(){};
    void calcRes();
};
 
FS::FS()
{
    x1=0;
    x2=0;
    extIn=0;
}
 
FS::FS( Uchar x1_, Uchar x2_, Uchar extIn_) : ALU( x1_, x2_, extIn_)
{
    calcRes();
}
 
void FS::calcRes()
{
    res  = x1^x2^extIn;
    extOut = ( (~x1)& x2 )| ( (~x1)& extIn )|( x2 & extIn ) ;
}
 
// -------------- class abstract ALU8 ---------------------------
 
class AbstractALU8
{
protected:
    AbstractALU8(){}
    ~AbstractALU8(){}
    virtual void calculate()=0; 
};
 
// --------------- class ALU8 -----------------------
 
class ALU8 : public AbstractALU8
{
protected:
    Uint byte1, byte2;
    Uint res;
    ALU *ALUArr[8];
public:
    ALU8();
    ALU8( Uint byte1_, Uint byte2_ );
    void setByte1( Uint byte1_ ){ byte1=byte1_;}
    void setByte2( Uint byte2_ ){ byte2=byte2_;}
    Uint getRes(){ return res; }
    void Print();
};
 
ALU8::ALU8()
{
    byte1=0;
    byte2=0;
    res=0;
    ALUArr[0]->setExtIn(0);  // В этом месте я застрял. Программа компилируется, но вызывает core dumped.
                            // Также не работает ALUArr[0]->extIn=0; 
                            // Помогите с этим, пожалуйста.
                    
}
 
ALU8::ALU8( Uint byte1_, Uint byte2_ )
{
    byte1=byte1_;
    byte2=byte2_;
    res=0;
    //ALUArr[0]->extIn=0;
}
 
void ALU8::Print()
{
    cout << "Inputs: byte1=" << (int)byte1 << ", byte2=" << (int)byte2 << endl;
    cout << "Outputs: res=" << res << endl;
}
 
// ------------------- class FA8 -------------------------------
 
class FA8 : public ALU8
{
public:
    FA8();
    FA8( Uint byte1_, Uint byte2_ );
    ~FA8(){}
    void calculate();
};
 
FA8::FA8()
{
    byte1=0;
    byte2=0;
    res=0;
    //ALUArr[0]->extIn=0;
}
 
FA8::FA8( Uint byte1_, Uint byte2_ ):ALU8( byte1_, byte2_ )
{
    //calculate();
}
 
void FA8::calculate()
{
    int count=1;
    //Uchar flag=1;
    //Uint temp1=byte1, temp2=byte2, tempres=0;
 
    //ALUArr[0]->extIn=0;
    //for(count=0; count<8; count++){
        //if(count!=0) ALUArr[count]->extIn=ALUArr[count-1]->extOut;
        //temp1=temp1&flag;
        //temp2=temp2&flag;
        //ALUArr[count]->setX1(temp1);
        //ALUArr[count]->setX2(temp2);
 
        //ALUArr[count]->res  = (ALUArr[count]->x1)^(ALUArr[count]->x2)^(ALUArr[count]->extIn);
        //ALUArr[count]->extOut = ( (ALUArr[count]->x1) & (ALUArr[count]->x2) ) | 
        //                  ( (ALUArr[count]->x1) & (ALUArr[count]->extIn) ) |
        //                      ( (ALUArr[count]->x2) & (ALUArr[count]->extIn) ) ;
        
        //flag=1<<flag;
    //}
 
    //flag=1;
    //res=0;
    //for(count=0; count<8; count++){
    //  tempres=(int)(ALUArr[count]->res)*flag;
    //  res+=tempres;
    //  flag*=10;
    //} 
}
 
//--------------- main() ----------------------------------------
 
int main()
{
    /*FA fa1(1,1,0);
    fa1.Display();
 
    FS fs1(0,1,0);
    fs1.Display();*/
 
    FA8 fa8;
    fa8.calculate();
    fa8.Print();
 
    return 0;
}

ALU *ALUArr[8];