how can i use class to programming c++

[antococo]

i have a question about the class in c++,

my code its regular and i dont know if the code its correct, so i need some help.

here I leave the code and if you see any error comment, thanks.

the code is about logic door, i need to have a mother class and the sons class have to do the code that i have put.

the first parts its with 3 entry and the second part its with multidoor


#############################################

//Declaración de la clase Puerta

#ifndef _PUERTA_
#define _PUERTA_


#define ND (5) //Para el valor no determinado le asignamos un valor de 5
#include <string> //Para poder hacer strings
#include <sstream> //para poder hacer los ostringstream


class Puerta { //La clase puerta es la ulima del circuito, por lo que no
//va predecidida de ninguna otra
protected://Los miembros declarados después de aqui estaran protegidos
//solo los podrá ver esta clase

int _id; //inicializamos el identificador

public://Los miembros declarados después de aqui estaran protegidos
//y los podran ver todas las clases

Puerta();

virtual int salida() = 0; //inicializamos a 0 el valor de la salida

int getId();//inicializamos la obtencion del indentificador

virtual std::string toString ( int nivel = 0 ) = 0;
};


#endif


###################################

//Definición de la clase Puerta

#include "Puerta.hpp" //incluimos Puerta.hpp ya que va enlazada a
//Puerta.cpp
int _numPuerta = 1; //inicializamos _numpuerta a 1
//al identificador le damos el valor del numero de la puerta
//y le sumamos 3
Puerta::Puerta(){
_id = _numPuerta;
_numPuerta = _numPuerta + 3;
}

//Obtenemos el valor de puerta y devolvemos
int Puerta::getId(){
return _id;
}

#####################################

//Declaración de la clase Fijo

#ifndef _FIJO_
#define _FIJO_

#include "Puerta.hpp"//Fijo va conectado directamente a Puerta.hpp
//entonces lo incluimos


class Fijo : public Puerta{
protected:

int _salPta = ND; //declaramos como variable protegida que _salPta es
//igual a ND
public: //Todo lo que hemos declarado despues de aqui es publico

void pon1(); //declaramos void con el valor 1 para despues en la puerta
//and retornar ese valor como uno de las posiblidades
void pon0(); ////declaramos void con el valor 0 para despues en la puerta
//and retornar ese valor como uno de las posiblidades
int salida();

std::string toString ( int nivel = 0 ) ;
};

std::ostream & operator<< (std::ostream & oss, Fijo & f);

#endif

#####################################

//Definición de la clase Fijo

#include "Fijo.hpp"

void Fijo::pon1(){
_salPta = 1; //Para el Pon1() devolvemos el valor de 1
}


void Fijo::pon0(){
_salPta = 0; //Para el Pon0() devolvemos el valor de 0
}

int Fijo::salida(){

return _salPta;

}
/*Aqui ajustamos para las conexiones que se conecten dejando 3 espa
* cios entre si, esto lo hacemos con la creacion de un valor entero
* el cual llamamos numEspacios que se encarga de multiplicar por 3
* el valor de nivel, el cual va aumentando gracias al contador que
* hemos hecho con nivel*/

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

int numEsp = nivel*3;

nivel++;

std::ostringstream oss;

std::string espacios(numEsp,' ');

oss << espacios << "Fijo id=" << _id << " salida=" << salida()
<< "\n";

return oss.str();
}

std::ostream & operator<< (std::ostream & oss, Fijo & f){

oss << f.toString(0);

return oss;

}

###############################

//Declaración de la clase Not

#ifndef _NOT_
#define _NOT_

#include "Puerta.hpp"
/*definimos un puntero con el cual nos uniremos a la puerta madre*/
class Not : public Puerta{

protected:
Puerta *_ptaE = nullptr; //null pointer

public:
void conecta(Puerta *pt);

int salida();

std::string toString(int nivel=0);
};

std::ostream& operator<< (std::ostream& oss, Not &f);

#endif


################################

//Definición de la clase Not

#include "Not.hpp"
/*Aqui lo que hacemos es proponer todos los casos posibles que se nos
* pueden presentar al conectar la puerta not, que devuelva 1,0, ND
* y en caso de que devuelva 1 o 0 cambiar su valor por el contrario*/

void Not::conecta(Puerta *pt){
_ptaE = pt;
}

int Not::salida(){
if (_ptaE == nullptr){

return ND;

}
int sal = _ptaE->salida();

if(sal == ND){

return ND;
}

if(sal == 1){

return 0;
}
return 1;
}

/*Aqui lo que hacemos es como dijimos antes crear nivel para poder
* incrementar de 3 en 3 el valor de los identificadores, además de esto,
* consideraremos y mostraremos por pantalla los resultados tanto si está
* conectada como si no lo está, estudiando todos los casos posibles
* para ello */

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

int numEsp = nivel*3;

nivel++;

std::ostringstream oss;

std::string espacios(numEsp,' ');

oss << espacios <<"Not id=" << _id << " salida=" <<salida()
<< "\n";

if (_ptaE == nullptr){

oss << espacios << " NO CONECTADA\n";
}
else{

oss << _ptaE->toString(nivel);
}

return oss.str();
}

std::ostream& operator<< (std::ostream& oss, Not &f){

oss << f.toString(0);

return oss;
}

################################

//Declaración de la clase And

#ifndef _AND_
#define _AND_

#include "Pta3Entradas.hpp"//La puerta va precedida de Pta3Entradas.hpp

class And :public Pta3Entradas{

public:
int salida();
std::string toString(int nivel=0);
};
std::ostream& operator<< (std::ostream& oss, And &f);

#endif

#####################################

//Definición de la clase And

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

/*Al ser una puerta and, solo nos podra devolver un valor de 1 si las 3
* entradas poseen el valor de 1, esto lo comprobaremos con el &&, si no
* ocurre esto, devolveremos un 0, también comprobaremos los casos en los
* que se nos devuelve ND*/

int And::salida(){

if (_ptaE1 == nullptr || _ptaE2 == nullptr || _ptaE3 == nullptr){
return ND;
}

int sal1 = _ptaE1->salida();
int sal2 = _ptaE2->salida();
int sal3 = _ptaE3->salida();

if (sal1 == ND || sal2 == ND || sal3 == ND){
return ND;
}

if (sal1 == 1 && sal2 == 1 && sal3 == 1){
return 1;
}

return 0;
}

/*Aqui lo que hacemos es como dijimos antes crear nivel para poder
* incrementar de 3 en 3 el valor de los identificadores, además de esto,
* consideraremos y mostraremos por pantalla los resultados tanto si está
* conectada como si no lo está, estudiando todos los casos posibles
* para ello */

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

int numEsp = nivel * 3;

nivel++;

std::ostringstream oss;

std::string espacios(numEsp , ' ');

oss << espacios << "And id=" << _id << " salida="
<< salida() << "\n";

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

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

else{
oss << _ptaE2->toString(nivel);
}

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

else{
oss << _ptaE3->toString(nivel);
}
return oss.str();
}

std::ostream & operator<< (std::ostream & oss, And & f){
oss << f.toString(0);
return oss;
}

[coder777]

Do you have any specific questions?

[dhayden]

I see one potential problem. Class Not contains a raw pointer (_ptaE). Who owns that pointer (meaning who is responsible for deleting it? Figure this out and document it in the conecta() method. If Not owns the pointer then you'll need to create assignment operators and copy constructors, or explicitly disallow them.