añadido parte2

parte2/include/Cliente.h

@@ -0,0 +1,31 @@
+#ifndef CLIENTE_H
+#define CLIENTE_H
+
+#include <iostream> //cin, cout
+#include "Fecha.h"
+
+using namespace std;
+//SI FALTA ALGUN METODO O FUNCION A<>ADIRLO...
+class Cliente {
+  long int dni;
+  char *nombre;
+  Fecha fechaAlta;
+public:
+  Cliente(long int d, const char *nom, Fecha f);
+  virtual ~Cliente();
+  Cliente& operator=(const Cliente& c);
+
+  long int getDni() const { return this->dni; }
+  const char* getNombre() const { return nombre; } //VIP devolver un puntero constante para evitar que desde el main() se puede modificar el nombre
+  Fecha getFecha() const { return fechaAlta; }
+
+  void setNombre(const char *nom);
+  void setFecha(Fecha f);
+
+  bool operator==(const Cliente& c) const; // if (c1 ===c2)
+
+};
+
+ostream& operator<<(ostream &s, const Cliente &c); //funcion no amiga de la clase
+
+#endif // CLIENTE_H

parte2/include/Contrato.h

@@ -0,0 +1,33 @@
+#ifndef CONTRATO_H
+#define CONTRATO_H
+
+#include <iostream> //cin, cout
+#include "Fecha.h"
+
+using namespace std;
+
+class Contrato {
+  static int contador;
+  const int idContrato;
+  long int dniContrato;
+  Fecha fechaContrato;
+public:
+  Contrato(long int dni, Fecha f);
+  virtual ~Contrato();
+//Contrato(const Contrato& c); //<2F>es necesario? pensar y reflexionad
+
+//Contrato& operator=(const Contrato& c); //no es necesario y ademas no puede ser usado porque Contrato tiene un
+                                          //atributo constante idContrato que no puede modificarse
+                                          //no se puede usar el = en el main con objetos Contrato
+
+  int getIdContrato() const { return this->idContrato; }
+  long int getDniContrato() const { return this->dniContrato; }
+  Fecha getFechaContrato() const { return this->fechaContrato; }
+  void setFechaContrato(Fecha f) { this->fechaContrato=f; }
+  void setDniContrato(long int dni) { this->dniContrato=dni; }
+  void ver() const;
+};
+
+ostream& operator<<(ostream &s, const Contrato &c);
+
+#endif // CONTRATO_H

parte2/include/ContratoMovil.h

@@ -0,0 +1,39 @@
+#ifndef CONTRATOMOVIL_H
+#define CONTRATOMOVIL_H
+
+#include <iostream> //cin, cout
+#include "Fecha.h"
+#include "Contrato.h"
+
+using namespace std;
+
+class ContratoMovil: public Contrato {
+  float precioMinuto;
+  int minutosHablados;
+  char *nacionalidad;
+public:
+  ContratoMovil(long int dni, Fecha f, float p, int m, char *nac);
+  virtual ~ContratoMovil(); //necesario porque hay un atributo puntero char*
+  ContratoMovil(const ContratoMovil& c); //necesario porque hay un atributo puntero char*
+
+//ContratoMovil& operator=(const ContratoMovil& c); //necesario si en el main pensamos usar = para asignar
+                                                    //si NUNCA vamos a usar = en el main no hace falta implementarlo
+                                                    //como ContratoMovil hereda un atributo constante idContrato que no puede modificarse
+                                                    //no podemos usar el = en el main() y por tanto no lo implementamos
+
+  float getPrecioMinuto() const { return this->precioMinuto; }
+  int getMinutosHablados() const { return this->minutosHablados; }
+  const char* getNacionalidad() const { return this->nacionalidad; } //IMPORTANTE devuelve un puntero constante
+  void setPrecioMinuto(float precio) { this->precioMinuto=precio; }
+  void setMinutosHablados(int m) { this->minutosHablados=m; }
+  void setNacionalidad(char* nac);
+  void ver() const;
+  float factura() const;
+};
+
+ostream& operator<<(ostream &s, const ContratoMovil &c);
+
+
+
+
+#endif // CONTRATOMOVIL_H

parte2/include/ContratoTP.h

@@ -0,0 +1,32 @@
+#ifndef CONTRATOTP_H
+#define CONTRATOTP_H
+
+#include <iostream> //cin, cout
+#include "Fecha.h"
+#include "Contrato.h"
+
+using namespace std;
+
+class ContratoTP: public Contrato {
+  static int minutosTP;
+  static float precioTP;
+  int minutosHablados;
+  static const float precioExcesoMinutos;
+
+public:
+  ContratoTP(long int dni, Fecha f, int m);
+  //virtual ~ContratoTP(); //<2F>es necesario? pensar y reflexionad
+  //ContratoTP(const ContratoTP& c);  //<2F>es necesario? pensar y reflexionad
+  //ContratoTP& operator=(const ContratoTP& c); //<2F>es necesario? pensar y reflexionad
+
+  static int getLimiteMinutos() { return ContratoTP::minutosTP; }
+  static float getPrecio() { return ContratoTP::precioTP; }
+  static void setTarifaPlana(int m, float p); //el el .cpp se pone la cabecera sin la palabra static
+
+  //A RELLENAR POR EL ALUMNO...
+
+};
+
+ostream& operator<<(ostream &s, const ContratoTP &c);
+
+#endif // CONTRATOTP_H

parte2/include/Fecha.h

@@ -0,0 +1,31 @@
+#ifndef FECHA_H
+#define FECHA_H
+
+#include <iostream> //cin, cout
+
+using namespace std;
+//SI FALTA ALGUN METODO O FUNCION A<>ADIRLO...
+class Fecha {
+  int dia;
+  int mes, anio;
+public:
+  Fecha(const int &dia, const int &m, const int &anio);
+//virtual ~Fecha(); //NO HACE FALTA
+//Fecha(const Fecha &f); //NO HACE FALTA: EL QUE GENERA EL COMPILADOR FUNCIONA BIEN YA QUE NO HAY PUNTEROS
+  int getDia() const { return dia; }
+  int getMes() const { return this->mes; }
+  int getAnio() const { return this->anio; }
+  void setFecha(const int &dia, const int &mes, const int &a);
+  void ver() const;
+  bool bisiesto() const;
+  Fecha operator++();   //++f
+  Fecha operator++(int i); //f++
+  Fecha operator+(const int &i) const; //f+5
+
+  friend Fecha operator+(const int &i, const Fecha &f); //const por seguridad y & por velocidad
+  friend ostream& operator<<(ostream& os, const Fecha& f);
+};
+
+Fecha operator+(const int &i, const Fecha &f); //const por seguridad y & por velocidad
+
+#endif // FECHA_H

parte2/src/Cliente.cpp

@@ -0,0 +1,58 @@
+#include <cstdlib>
+#include <cstring> //strlen, strcpy
+#include <iomanip> //std::setprecision
+#include <sstream> //stringstream
+#include "Cliente.h"
+
+//Cliente::Cliente(long int d, char *nom, Fecha f):fechaAlta(f.getDia(), f.getMes(), f.getAnio()) {
+Cliente::Cliente(long int d,const char *nom, Fecha f):fechaAlta(f) { //esta cabecera es mas corta (invoco
+  this->dni=d;                                                  //constructor copia de fecha
+                                                                //en vez de constructor de 3 parametros)
+  //this->nombre=nombre;  //MAL!!!!
+  this->nombre=new char[strlen(nom)+1];
+  strcpy(this->nombre, nom);
+
+  //this->fechaAlta=f;//MAL!!!! los tipos no primitivos debe ir en zona inicializadores
+}
+
+Cliente::~Cliente() {
+  delete [] this->nombre; //si en el constructor uso new [] en el destructor uso delete []
+}
+
+Cliente& Cliente::operator=(const Cliente& c) {
+  if (this != &c) { //si no es x=x
+    this->dni=c.dni;
+    delete [] this->nombre;
+    //this->nombre=c.nombre;  //MAL!!!!
+    this->nombre=new char[strlen(c.nombre)+1];
+    strcpy(this->nombre, c.nombre);
+    this->fechaAlta=c.fechaAlta;
+  }
+  return *this;
+}
+
+bool Cliente::operator==(const Cliente& c) const {
+  if (this->dni!=c.dni) return false;
+  if (strcmp(this->nombre, c.nombre)!=0) return false;
+  if (this->fechaAlta.getDia()!=c.fechaAlta.getDia() ||
+      this->fechaAlta.getMes()!=c.fechaAlta.getMes() ||
+      this->fechaAlta.getAnio()!=c.fechaAlta.getAnio()) return false;
+  return true;
+}
+
+//RESTO DE METODOS Y FUNCIONES A RELLENAR POR EL ALUMNO..
+
+void Cliente::setNombre(const char *nom){
+	delete[] this->nombre;
+	this->nombre = new char[strlen(nom)+1];
+	strcpy(this->nombre, nom);
+}
+
+ostream& operator<<(ostream& os, const Cliente& c) {
+    os << c.getDni() << " - " << c.getNombre() << " (" << c.getFecha() << ")";
+    return os;
+}
+
+void Cliente::setFecha(Fecha f) {
+    this->fechaAlta = f;
+}

parte2/src/Contrato.cpp

@@ -0,0 +1,28 @@
+#include "Contrato.h"
+
+int Contrato::contador=1;
+
+Contrato::Contrato(long int dni, Fecha f): idContrato(contador), fechaContrato(f) {
+  //idContrato=contador; //ERROR es constante y debe ir en zona inicializadores
+  Contrato::contador++;
+  this->dniContrato=dni;
+  //this->fechaContrato=f; //ERROR es tipo no primitivo y debe ir en zona inicializadores
+}
+
+Contrato::~Contrato() {
+    //dtor
+}
+
+
+void Contrato::ver() const {
+  cout << this->dniContrato << " (" << this->idContrato << " - ";
+  this->fechaContrato.ver(); //llamo al ver del objeto fecha
+  cout << ")";
+}
+
+ostream& operator<<(ostream &s, const Contrato &c) {
+  s << c.getDniContrato() << " (" << c.getIdContrato() << " - " << c.getFechaContrato() << " )";
+  return s;
+}
+
+//RESTO DE METODOS Y FUNCIONES A RELLENAR POR EL ALUMNO...

parte2/src/ContratoMovil.cpp

@@ -0,0 +1,53 @@
+#include <iostream>
+#include <cstdlib>
+#include <cstring> //strlen, strcpy
+#include <iomanip> //std::setprecision
+#include "Contrato.h"
+#include "ContratoMovil.h"
+
+ContratoMovil::ContratoMovil(long int dni, Fecha f, float p, int m, char *nac): Contrato(dni, f) {
+  this->precioMinuto=p;
+  this->minutosHablados=m;
+  //this->nacionalidad=nac;  //MAL!!!!
+  this->nacionalidad=new char [strlen(nac)+1];
+  strcpy(this->nacionalidad, nac);
+}
+
+ContratoMovil::~ContratoMovil() {
+  //implementarlo...
+}
+
+//ContratoMovil::ContratoMovil(const ContratoMovil& c):Contrato(c) { //IMPORTANTE: SI PONGO ESTA CABECERA y no implemento un constructor de copia en CONTRATO
+                                                                     //NO DA ERROR AL COMPILAR PORQUE EL COMPILADOR GENERA UN CONSTRUCTOR COPIA POR SU CUENTA...
+                                                                     //...EL PROBLEMA ES QUE EL QUE GENERA EL COMPILADOR NO INCREMENTA contador
+                                                                     //Y ASIGNARIA EL MISMO CODIGO A AMBOS CONTRATOS
+                                                                     //solucion: implementar constructor copia en CONTRATO y usar esta cabecera...
+ContratoMovil::ContratoMovil(const ContratoMovil& c):Contrato(c.getDniContrato(), c.getFechaContrato()) { //... o usar esta otra cabecera
+  this->precioMinuto=c.precioMinuto;
+  //terminar de implementarlo...
+}
+
+void ContratoMovil::ver() const {
+  Contrato::ver(); //IMPORTANTE: llamamos al ver que heredo de mi padre PARA QUE MUESTRE LO DEL PADRE
+                   //... y a continuacion solo "me preocupo" de mostrar lo que es exclusivo del hijo
+  cout << " " << this->minutosHablados << "m, " << this->nacionalidad << " " << this->precioMinuto;
+}
+
+float ContratoMovil::factura() const {
+  //implementarlo...
+}
+
+
+void ContratoMovil::setNacionalidad(char* nac) {
+  //implementarlo...
+}
+
+ostream& operator<<(ostream &s, const ContratoMovil &c) {
+  s << (Contrato &)c; //IMPORTANTE: convierto el objeto c (ContratoMovil &) a objeto Contrato &
+                      // de esta forma se cree que es un objeto Contrato y muestra lo que indica el operator<< de Contrato
+                      //... y a continuacion solo "me preocupo" de mostrar lo que es exclusivo del hijo
+  s << " " << c.getMinutosHablados() << "m, " << c.getNacionalidad() << " " << c.getPrecioMinuto() << " - ";
+  s << c.factura() << "<EFBFBD>";
+  return s;
+}
+

parte2/src/ContratoTP.cpp

@@ -0,0 +1,14 @@
+#include "ContratoTP.h"
+
+int ContratoTP::minutosTP=300;
+float ContratoTP::precioTP=10;
+const float ContratoTP::precioExcesoMinutos=0.15;
+
+
+//static se pone en el .h (no se pone en el .cpp)
+void ContratoTP::setTarifaPlana(int m, float p) {
+  ContratoTP::minutosTP=m; //puedo poner minutosTP=m ...pongo ContratoTP::minutosTP para recordar que es estatico
+  ContratoTP::precioTP=p;  //puedo poner precioTP=p  ...pongo ContratoTP::precioTP para recordar que es estatico
+}
+
+//RESTO DE METODOS Y FUNCIONES A RELLENAR POR EL ALUMNO...

parte2/src/Fecha.cpp

@@ -0,0 +1,99 @@
+#include "Fecha.h"
+
+Fecha::Fecha(const int &dia, const int &m, const int &anio) {
+    this->setFecha(dia, m, anio); //el cogido es el mismo que el del metodo setFecha
+}
+
+void Fecha::setFecha(const int &dia, const int &mes, const int &a) {
+    int dmax, diaMes[] = {0,31,28,31,30,31,30,31,31,30,31,30,31};
+    this->anio=a; //VIP debo asignar a<>o para que al llamar a bisiesto() tenga el a<>o bien
+    if (this->bisiesto())
+        diaMes[2]=29;
+
+    if (mes<1)  //si el mes es incorrecto
+      this->mes=1;
+    else if (mes>12) //si el mes es incorrecto
+      this->mes=12;
+    else
+      this->mes=mes;
+    dmax=diaMes[this->mes]; //una vez fijado el mes veo cuantos dias tiene ese mes como maximo
+
+    if (dia>dmax) //si dia es superior al numero de dias de dicho mes
+      this->dia=dmax;
+    else if (dia<1) //si dia es inferior a 1
+      this->dia=1;
+    else
+      this->dia=dia;
+}
+
+bool Fecha::bisiesto() const {
+    if (this->anio%4==0 && (this->anio%100!=0 || this->anio%400==0  )) //esto no es exacto... corregidlo ustedes
+        return true;
+    else
+        return false;
+}
+
+void Fecha::ver() const {
+  if (this->dia < 10)
+    cout << "0";
+  cout << this->dia << "/";
+  if (this->mes < 10)
+    cout << "0";
+  cout << this->mes << "/" << this->anio;
+}
+
+Fecha Fecha::operator++() {   //++f
+    int dmax, diaMes[] = {0,31,28,31,30,31,30,31,31,30,31,30,31};
+    if (this->bisiesto()) //si el a<>o es bisiesto febrero tiene 29 dias
+      diaMes[2]=29;
+    dmax=diaMes[this->mes];
+    this->dia++;
+    if (this->dia>dmax) { //si al incrementar dia superamos el numero de dias de dicho mes
+        this->dia=1;      //pasamos a 1
+        this->mes++;      //del mes siguiente
+        if (this->mes>12) { //si al incrementar mes pasamos de 12 meses
+            this->mes=1;    //pasamos al mes 1
+            this->anio++;   //del a<>o siguiente
+        }
+    }
+    return *this; //devolvemos el objeto fecha ya incrementado
+}
+
+//RESTO DE METODOS Y FUNCIONES A RELLENAR POR EL ALUMNO...
+
+
+Fecha Fecha::operator++(int) {   //f++
+    Fecha temp = *this;
+
+    int dmax, diaMes[] = {0,31,28,31,30,31,30,31,31,30,31,30,31};
+    if (this->bisiesto()) //si el a<>o es bisiesto febrero tiene 29 dias
+      diaMes[2]=29;
+    
+    dmax=diaMes[this->mes];
+    this->dia++;
+    if (this->dia>dmax) { //si al incrementar dia superamos el numero de dias de dicho mes
+        this->dia=1;      //pasamos a 1
+        this->mes++;      //del mes siguiente
+        if (this->mes>12) { //si al incrementar mes pasamos de 12 meses
+            this->mes=1;    //pasamos al mes 1
+            this->anio++;   //del a<>o siguiente
+        }
+    }
+    
+    return temp; //devolvemos el objeto antes del incrementado
+}
+
+ostream& operator<<(ostream& os, const Fecha& f) {
+    os << f.getDia() << "/" << f.getMes() << "/" << f.getAnio();
+    return os;
+}
+
+
+Fecha Fecha::operator+(const int &dias)const {   //f+5
+    Fecha resultado = *this;
+    for(int i = 0; i < dias; i++){
+    	++resultado;
+    }
+    return *this;	
+}
+

parte2/src/main.cpp

@@ -0,0 +1,48 @@
+#include <cstdlib>
+#include <iostream>
+#include <iomanip> //std::setprecision
+#include <filesystem> //std::filesystem::exists
+#include "Fecha.h" //definicion de la clase Fecha
+#include "Contrato.h" // definicion de la clase Contrato
+#include "ContratoTP.h" // definicion de la clase ContratoTP
+#include "ContratoMovil.h" // definicion de la clase ContratoMovil
+
+using namespace std;
+
+int main(int argc, char *argv[]) {
+	Fecha f1(29,2,2001), f2(f1), f3(29,2,2004);
+	cout << "Fechas: ";
+	f1.ver(); cout << ", "; f2.ver(); cout << ", "; f3.ver(); cout << endl;
+
+	Contrato *p = new Contrato(75547111, f1), c(23000111, Fecha(2,2,2002));
+	cout << ContratoTP::getLimiteMinutos() << " - " << ContratoTP::getPrecio() << endl;
+	ContratoTP ct1(17333256, f1, 250); //habla 250 minutoe
+	ContratoTP ct2(12555100, f3, 320); //habla 320 minutos
+	ContratoTP ct3(ct1);
+	ContratoMovil cm1(17333256, f1, 0.12, 100, "ESPA<EFBFBD>OL"); //habla 100 minutos
+	ContratoMovil cm2(17000000, Fecha(3,3,2003), 0.10, 180, "FRANCES"); //habla 180 minutos
+	ContratoMovil cm3(cm2);
+	p->ver(); cout << "\n"; c.ver(); cout << endl;
+	ct1.ver(); cout << endl; ct2.ver(); cout << "\n"; ct3.ver(); cout << "\n";
+	cm1.ver(); cout << endl; cm2.ver(); cout << "\n"; cm3.ver(); cout << "\n";
+	cout << p->getIdContrato() << ct2.getIdContrato() << cm2.getIdContrato() << endl;
+
+	cout << setprecision(2) << fixed; //a partir de aqui float se muestra con 2 decimales
+
+	cout << "Facturas: " << ct1.factura() <<"-"<< ct2.factura() <<"-"<< cm1.factura() << endl;
+	ContratoTP::setTarifaPlana(350, 12); //350 minutos por 12 euros
+	p->setDniContrato(cm1.getDniContrato());
+	ct3.setFechaContrato(p->getFechaContrato()+1);
+	cm3.setNacionalidad(cm1.getNacionalidad());
+	cm2.setPrecioMinuto(cm1.getPrecioMinuto()+0.02);
+	cm1.setMinutosHablados(ct2.getMinutosHablados()/2);
+	ct1.setMinutosHablados(cm3.getMinutosHablados()*2);
+	cout << *p <<"\n"<< c << endl;
+	cout << ct1 <<endl<< ct2 <<"\n"<< ct3 <<"\n"<< cm1 <<"\n"<< cm2 <<endl<< cm3 << endl;
+
+	if (std::filesystem::exists("/etc/os-release")){
+		system("read -p 'Presione una tecla para continuar' " ); return 0;
+	}else{
+		system("PAUSE"); return 0;
+	}
+}