Puerta.hpp

#ifndef _PUERTA_
#define _PUERTA_

#define ND (7)
#include <string>

class Puerta {

protected:
static int _numSerie;
int _id;

public:
Puerta();
virtual int salida() = 0;
virtual int getId() = 0;
virtual std::string toString(int nivel = 0) = 0;

};

#endif


Puerta cpp

#include "Puerta.hpp"

int Puerta::_numSerie = 2; //Inicializamos


Puerta::Puerta() {

_id = _numSerie;
_numSerie+=2;

}

fijo hpp

#ifndef _FIJO_
#define _FIJO_

#include "Puerta.hpp"

class Fijo : public Puerta {

protected:
int _estado = ND;

public:
int salida();
int getId();
std::string toString(int nivel = 0);
void pon1();
void pon0();

};

std::ostream& operator<< (std::ostream& os, Fijo& m);

#endif

fijo cpp

#include "Fijo.hpp"

void Fijo::pon1(){

_estado = 1;
}
void Fijo::pon0(){

_estado = 0;
}

int Fijo::salida(){

return _estado;
}

int Fijo::getId(){

return _id;
}

std::string Fijo::toString(int nivel){

std::string respuesta;
std::string espacios(nivel*4, ' ');

respuesta = espacios + "Fijo id=" + std::to_string(getId() ) + " salida="
+ std::to_string(salida() ) + "\n";

return respuesta;

}

std::ostream& operator<< (std::ostream& os, Fijo& m){

os << m.toString(0);
return os;
}


conectar puerta hpp

#ifndef _CONECTARENTRADAS_
#define _CONECTARENTRADAS_

//Hija directa de PUerta por lo cual:
#include "Puerta.hpp"

class ConectarEntradas : public Puerta {

protected:
//Mediante punteros:

Puerta* _ptE1 = nullptr;
Puerta* _ptE2 = nullptr;
Puerta* _ptE3 = nullptr;

public:

void conecta1(Puerta *pt);
void conecta2(Puerta *pt);
void conecta3(Puerta *pt);
};

#endif

conectar entradas cpp

#include "ConectarEntradas.hpp"

void ConectarEntradas::conecta1(Puerta *pt){

_ptE1 = pt;
}

void ConectarEntradas::conecta2(Puerta *pt){

_ptE2 = pt;
}

void ConectarEntradas::conecta3(Puerta *pt){

_ptE3 = pt;
}

NANDM hpp

#ifndef _NAND_
#define _NAND_

//Hija directa de ConectarEntradas:
#include "ConectarEntradas.hpp"

class Nand : public ConectarEntradas {

public:

int salida();
int getId();
std::string toString(int nivel = 0);

};

std::ostream& operator<< (std::ostream& os, Nand& m);

#endif


nand cpp

#include "Nand.hpp"
#include <sstream>

int Nand::salida(){

//Cuando alguna de sus entradas no esté conectda devuelve ND:
if(_ptE1 == nullptr || _ptE2 == nullptr || _ptE3 == nullptr){
return ND;
}

//Si alguna de las entradas tiene valor ND, devolver ND pero antes
//debemos recoger lo que llega a dicha entrada:

int vEntradaNand1 = _ptE1 -> salida();
int vEntradaNand2 = _ptE2 -> salida();
int vEntradaNand3 = _ptE3 -> salida();

if(vEntradaNand1 == ND || vEntradaNand2 == ND || vEntradaNand3 == ND){
return ND;
}

//Operación lógica NAND 2 entradas -> And negada:

if((vEntradaNand1) == 1 && (vEntradaNand2 == 1) && vEntradaNand3 == 1){
return 0;
}else{
return 1;
}


}

int Nand::getId(){

return _id;
}

std::string Nand::toString(int nivel ){

std::ostringstream oss;
std::string espacios(nivel*4, ' ');

oss << espacios << "Nand id=" << getId() << " salida=" << salida()
<< "\n";

//Entradas y tenemos en cuenta si hay alguna mal conectada:

if(_ptE1 == nullptr){
oss << espacios << " NO CONECTADA\n";
}else{
oss << espacios << _ptE1 ->toString(1);
}


if(_ptE2 == nullptr){
oss << espacios << " NO CONECTADA\n";
}else{

oss << espacios << _ptE2 ->toString(1);
}

if(_ptE3 == nullptr){
oss << espacios << " NO CONECTADA\n";
}else{
oss << espacios << _ptE3 ->toString(1);
}


return oss.str();
}

std::ostream& operator<< (std::ostream& os, Nand& m){

os << m.toString(0);
return os;
}