Pineapple

[Mosquetero]

#include <string>
#include <iostream>
#include <cmath>
#include <fstream>
#include <vector>

/*int buscar_menores(int pivote const std::vector<std::string> &datos,
std::vector<int> &menores);*/
int pasar_decimal (int pivote, const std::vector<std::string> &datos,
std::vector<int> decimales);

int main(int argc, char *argv[]){
int pivote = 32;
std::string numero_binario;
std::vector<std::string> datos;
std::vector<int> decimales;
std::vector<int> menores;
std::ifstream fent;
if(argc < 2){
std::cerr << "Es necesario especificar el fichero que " <<
"desea abrir";
return 1;
}
if(argc == 3){
pivote = std::atoi(argv[2]);
}
if(argc > 3){
std::cerr << "Solo se admiten tres parametros de entrada.";
return 1;
}
std::string nombre = argv[1];
std::string nombre_fichero = nombre;
std::size_t buscardat = nombre.find(".dat");
std::size_t buscardatos = nombre.find("datos");
if(buscardat == std::string::npos){
nombre_fichero = nombre_fichero + ".dat";
}
if(buscardatos == std::string::npos){
nombre_fichero = "datos" + nombre_fichero;
}
std::cerr << "\n\nFichero a abrir: " << nombre_fichero << ".\n";
fent.open(nombre_fichero);
if(fent.fail()){
std::cerr << "\n\nNo se pudo leer el archivo";
return 2;
}
fent >> numero_binario;
while(fent.good()){
datos.push_back(numero_binario);
fent >> numero_binario;
}
std::cerr << "\nSe han leido los siguientes datos: ";
for(std::size_t i = 0 ; i < datos.size() ; i++){
if(i == 0){
std::cerr << datos[i];
}
else if(i > 0 && i < (datos.size() - 1)){
std::cerr << ", " << datos[i];
}
else{
std::cerr << ", " << datos[i] << ".\n" << std::endl;
}
}
pasar_decimal( pivote, datos, decimales);
fent.close();
}

// Declaración de la clase Puerta
// Autor:
// Fecha: 26/10/ 2017

#ifndef _PUERTA_
#define _PUERTA_

#define ND (9)

#include <string>


class Puerta {

protected:
static int _numSerie; //Como hay herencia y queremos que nuestras clases hijas
int _id;
std::string _nombre;

public:

Puerta (); //constructor
Puerta(std::string nom);

virtual int salida() const = 0; //Queremos que se tengan en cuenta las
//modificaciones que hacen las clases hijas
virtual std :: string info(int numEspacios = 0) const = 0;
//Clases abstractas, no puede instanciar objetos
};
#endif


// Definición de la clase Puerta
// Autor:
// Fecha: 26/10/ 2017

#include "Puerta.hpp"

int Puerta :: _numSerie =0;

Puerta::Puerta(){ //Hay que definirlo
_id = _numSerie;
_numSerie += 1;
}


Puerta::Puerta(std::string nom) : Puerta() {
_nombre = nom;
}

// Declaración de la clase Uno
// Autor:
// Fecha: 26/10/ 2017

#ifndef _UNO_
#define _UNO_

#include "Puerta.hpp"

class Uno : public Puerta {

public:
int salida() const;
std :: string info(int numEspacios = 0) const;
};
#endif


// Definición de la clase Puerta
// Autor:
// Fecha: 26/10/ 2017

#include "Uno.hpp"

int Uno :: salida() const {
return 1;
}
std :: string Uno :: info(int numEspacios) const {
std::string respuesta;
std::string espacios(numEspacios, ' ' );
respuesta = espacios + "Puerta UNO (id=" + std::to_string(_id) + ")\n";
return respuesta;

}


// Declaración de la clase NOT
// Autor:

#ifndef _NOT_
#define _NOT_

#include "PtaAlMenos1Entrada.hpp"

class Not : public PtaAlMenos1Entrada {

public:
int salida() const;

std::string info(int numEspacios = 0) const;
};


#endif
// Definición de la clase Not
// Autor:


#include "Not.hpp"

#include <sstream>
#include <iostream>

int Not::salida() const {
if (_ptE1 == nullptr)
return ND;

int ve = _ptE1->salida();

if (ve == ND)
return ND;

return ! ve;
}

std::string Not::info(int numEspacios) const {
std::cout<<"Entrando en el info de la puerta"<< _id << std::endl;
std::ostringstream oss;
std::string espacios(numEspacios, ' ');
oss << espacios << "Puerta NOT (id=" << _id << ") salida = "
<< salida() << "\n";

if (_ptE1 != nullptr) {
oss << _ptE1 -> info(numEspacios + 2);

}
else {

oss << espacios << " NO CONECTADA" <<std::endl;
}

return oss.str();
}


// Declaración de la clase PtaAlMenos1Entrada
// Autor:

#ifndef _PTAALMENOS1ENTRADA_
#define _PTAALMENOS1ENTRADA_
#include "Puerta.hpp"


class PtaAlMenos1Entrada : public Puerta {

protected:

Puerta* _ptE1 = nullptr;

public:

PtaAlMenos1Entrada(std::string nom);
PtaAlMenos1Entrada() = default;

void conecta1(Puerta* pt);
using Puerta::Puerta;

};

#endif



// Definición de la clase PtaAlMenos1Entrada
// Autor:


#include "PtaAlMenos1Entrada.hpp"

PtaAlMenos1Entrada::PtaAlMenos1Entrada(std::string nom) : Puerta(nom) {

}

void PtaAlMenos1Entrada::conecta1(Puerta* pt) {
_ptE1 = pt;
}

// Declaración de la clase Fijo
// Autor:
// Fecha: 26/10/ 2017

#ifndef _FIJO_
#define _FIJO_

#include "Puerta.hpp"

class Fijo : public Puerta {

protected:

int _estado = ND;

public:

Fijo(std::string nombre);
Fijo() = default;

virtual int salida() const;
virtual std :: string info(int numEspacios = 0) const;

void pon1();
void pon0();

};
#endif


// Definición de la clase fijo
// Autor:
// Fecha: 26/10/ 2017

#include "Fijo.hpp"

#include "sstream"

Fijo::Fijo(std::string nom) : Puerta(nom){

}

int Fijo::salida() const {
return _estado;
}

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

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


std :: string Fijo :: info(int numEspacios) const {


std::ostringstream oss;
std::string espacios(numEspacios, ' ' );
oss << espacios << "Puerta FIJO (id=" << _id << ") salida = "
<< salida() << "\n";

return oss.str();
}

// Declaración de la clase And
// Autor:
// Fecha: 26/10/ 2017

#ifndef _AND_
#define _AND_

#include "PtaAlMenos2Entradas.hpp"

class And : public PtaAlMenos2Entradas {

protected:

public:
And(std::string nom);
And() = default;

int salida() const;
std::string info(int numEspacios = 0) const;

};


#endif

// Definición de la clase And
// Autor:
// Fecha: 26/10/ 2017

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

And::And(std::string nom) : PtaAlMenos2Entradas(nom) {

}

int And :: salida() const {

if ((_ptE1 == nullptr) || (_ptE2 == nullptr)) {
return ND;
}

int ve = _ptE1->salida();
int ve2 = _ptE2->salida();

if ((ve == ND) || (ve2 == ND)) {
return ND;
}
if ((ve ==1) && (ve2 ==1)) {
return 1;
} else {
return 0;
}
}

// Declaración de la clase PtaAlMenos2Entradas
// Autor:

#ifndef _PTAALMENOS2ENTRADAS_
#define _PTAALMENOS2ENTRADAS_

#include "PtaAlMenos1Entrada.hpp"


class PtaAlMenos2Entradas : public PtaAlMenos1Entrada {

protected:

Puerta* _ptE2 = nullptr;

public:

PtaAlMenos2Entradas(std::string nom);
PtaAlMenos2Entradas() = default;

void conecta2(Puerta* pt);
};
#endif

// Definición de la clase PtaAlMenos2Entradas
// Autor:

#include "PtaAlMenos2Entradas.hpp"

PtaAlMenos2Entradas::PtaAlMenos2Entradas(std::string nom)
: PtaAlMenos1Entrada(nom) {
}

void PtaAlMenos2Entradas::conecta2(Puerta* pt) {
_ptE2 = pt;
}

[Ganado]

No tienes una pregunta.

Edit: I see you're just a troll or a really stupid bot now. I regret not reporting earlier...