Foro de elhacker.net

Programación => Programación C/C++ => Mensaje iniciado por: DvNe en 2 Abril 2014, 21:44 pm


Título: Pasar 'this' como parametro
Publicado por: DvNe en 2 Abril 2014, 21:44 pm
Buenas,

Estoy realizando una clase Tarjeta, la cual tiene el siguiente constructor:
Código
  1. #include "tarjeta.h"
  2. #include "usuario.h"
  3.  
  4. using namespace std;
  5.  
  6. Tarjeta::Tarjeta (const Numero& numero, const Usuario &user, const Fecha& caducidad) : numero_(numero), user_(&user), caducidad_(caducidad) {
  7.   Fecha f_actual;
  8.   titular_ = user.nombre() + " " + user.apellidos();
  9.  
  10.   if (caducidad_ < f_actual)
  11.     throw(Tarjeta::Caducada(caducidad_));
  12.   //(&user).es_titular_de(*this);
  13. } 
  14.  

Por otro lado, aquí tenemos la cabecera tarjeta.h

Código
  1. #ifndef _TARJETA_H_
  2. #define _TARJETA_H_
  3.  
  4. #include "fecha.h"
  5. #include "cadena.h"
  6. #include "numero.h"
  7.  
  8. class Usuario;
  9.  
  10. class Tarjeta {
  11.  public:
  12.   class Caducada {
  13.   public:
  14.     Caducada (const Fecha& f) : fecha_(f) {}
  15.     Fecha cuando() const { return fecha_; }
  16.   private:
  17.     Fecha fecha_;
  18.   };
  19.  
  20.   Tarjeta (const Numero&, const Usuario&, const Fecha&);
  21.  
  22.   Numero numero() const { return numero_; }
  23.   Fecha caducidad() const { return caducidad_; }
  24.   Cadena titular_facial() const { return titular_; }
  25.   const Usuario* titular() const { return user_; }
  26.   void anula_titular();
  27.  
  28.   friend std::ostream& operator << (std::ostream&, const Tarjeta&);
  29.  private:
  30.   Numero numero_; //Numero de identificacion de la tarjeta
  31.   const Usuario * const user_; //Puntero constante al usuario dueño
  32.   Fecha caducidad_; //Fecha de caducidad
  33.   Cadena titular_; // Nombre y apellidos del dueño
  34.  
  35.   Tarjeta (const Tarjeta&);//Deshabilitamos copia de una tarjeta
  36. };
  37. #endif

Y por otro lado, los archivos de USUARIO:

Código
  1. #ifndef _USUARIO_H_
  2. #define _USUARIO_H_
  3.  
  4. #include "cadena.h"
  5. #include "clave.h"
  6. #include "articulo.h"
  7. #include "tarjeta.h"
  8. #include "numero.h"
  9.  
  10. #include <sstream> //ostringstream
  11. #include <map>
  12. #include <set>
  13. using std::map;
  14. using std::set;
  15.  
  16. class Tarjeta;
  17.  
  18. class Usuario {
  19.  public:
  20.   //CONSTRUCTOR Y DESTRUCTOR
  21.   Usuario (const Cadena&, const Cadena&, const Cadena&, const Cadena&, const char*);
  22.   //~Usuario();
  23.  
  24.   class Id_duplicado {
  25.   public:
  26.     Id_duplicado (const Cadena& id) : id_duplicado(id) {}
  27.     const Cadena idd() { return id_duplicado; }
  28.   private:
  29.     const Cadena id_duplicado;
  30.   };
  31.   //FUNCIONES OBSERVADORAS
  32.   Cadena id() const { return identificador_; }
  33.   Cadena nombre() const { return nombre_; }
  34.   Cadena apellidos() const { return apellidos_; }
  35.   Cadena direccion() const { return direccion_; }
  36.   Cadena password() const { return password_.clave(); }
  37.  
  38.   //FUNCIONES CON TARJETAS
  39.   typedef map<Numero, Tarjeta*> Tarjetas;
  40.   void es_titular_de(Tarjeta&);
  41.   /*
  42.   
  43.   void no_es_titular_de(Tarjeta&);
  44.   const Tarjetas& tarjetas() const;
  45.   */
  46.  
  47.   //FUNCIONES CON LOS ARTICULOS
  48.   typedef map<Articulo*, unsigned> Articulos;
  49.   void compra(Articulo&, unsigned);
  50.   const Articulos& compra() const { return articulos_; } 
  51.   size_t n_articulos() const { return articulos_.size(); }
  52.  
  53.   //SOBRECARGA OPERADOR 
  54.   friend std::ostream& operator << (std::ostream&, const Usuario&); 
  55.  
  56.  private:
  57.   Cadena identificador_;
  58.   Cadena nombre_;
  59.   Cadena apellidos_;
  60.   Cadena direccion_; 
  61.   Clave password_;
  62.   /*  
  63.       Tarjetas tarjetas_;*/
  64.   Articulos articulos_;
  65.  
  66.   static set<Cadena> identificadores;
  67.   bool IdValido() const throw(Usuario::Id_duplicado);
  68.   Usuario (const Usuario&); //Deshabilitamos la copia de un usuario
  69. };
  70.  
  71. void mostrar_carro(std::ostringstream&, const Usuario&);
  72. //inline const Tarjetas& tarjetas() const { return tarjetas_; }
  73.  
  74. #endif

El problema es que cada vez que se crea una tarjeta, su constructor, debe asociar al usuario dueño la existencia de dicha tarjeta con la función void es_titular_de(Tarjeta&);

Pero no sé hacerlo ya que me sale un error diciendo:

pasar ‘const Usuario’ como el argumento ‘this’ de ‘void Usuario::es_titular_de(Tarjeta&)’ descarta a los calificadores

Título: Re: Pasar 'this' como parametro
Publicado por: ivancea96 en 2 Abril 2014, 22:37 pm
Pon un ejemplo donde falle. Un fragmento de código que falla ayudaría bastante.

Título: Re: Pasar 'this' como parametro
Publicado por: amchacon en 2 Abril 2014, 22:56 pm
No metas clases dentro de otras, aunque sintacticamente se puede (usando el operador de ambito "::") no es adecuado ni una buena costumbre. Te vas a llevar muchos dolores de cabeza innecesariamente.

Defina la clase fuera:

Código
  1. #include "fecha.h"
  2. #include "cadena.h"
  3. #include "numero.h"
  4.  
  5. class Usuario;
  6.  
  7. class Caducada
  8. {
  9. public:
  10.     Caducada (const Fecha& f) : fecha_(f) {}
  11.     Fecha cuando() const
  12.     {
  13.         return fecha_;
  14.     }
  15. private:
  16.     Fecha fecha_;
  17. };
  18.  
  19. class Tarjeta
  20. {
  21. public:
  22.  
  23.     Tarjeta (const Numero&, const Usuario&, const Fecha&);
  24.  
  25.     Numero numero() const
  26.     {
  27.         return numero_;
  28.     }
  29.     Fecha caducidad() const
  30.     {
  31.         return caducidad_;
  32.     }
  33.     Cadena titular_facial() const
  34.     {
  35.         return titular_;
  36.     }
  37.     const Usuario* titular() const
  38.     {
  39.         return user_;
  40.     }
  41.     void anula_titular();
  42.  
  43.     friend std::ostream& operator << (std::ostream&, const Tarjeta&);
  44. private:
  45.     Numero numero_; //Numero de identificacion de la tarjeta
  46.     const Usuario * const user_; //Puntero constante al usuario dueño
  47.     Fecha caducidad_; //Fecha de caducidad
  48.     Cadena titular_; // Nombre y apellidos del dueño
  49.  
  50.     Tarjeta (const Tarjeta&);//Deshabilitamos copia de una tarjeta
  51. };
  52. #endif
  53.  

Título: Re: Pasar 'this' como parametro
Publicado por: DvNe en 2 Abril 2014, 23:11 pm
Código
  1. Usuario* pU;
  2. pU = new Usuario("pperez","Perico","Perez Palotes","13 Rue del Percebe","pedrofueacomprarpan");
  3.     try {
  4. 	const Tarjeta t(numer,*pU,Fecha(6,5,2020));
  5.     }  catch (Tarjeta::Caducada e) {
  6. 	cerr << "Excepcion: Tarjeta caducada " << e.cuando() <<endl;
  7.     }

Título: Re: Pasar 'this' como parametro
Publicado por: ivancea96 en 3 Abril 2014, 15:08 pm
Prueba a poner, en vez de:
Código
  1. (&user).es_titular_de(*this);

Pones:
Código
  1. user.es_titular_de(*this);

Sinó, prueba a declarar "es_titular_de()" como const. (Siempre que realmente sea const, claro)

Título: Re: Pasar 'this' como parametro
Publicado por: eferion en 3 Abril 2014, 15:48 pm
Código
  1. Tarjeta::Tarjeta (const Numero& numero, const Usuario &user, const Fecha& caducidad) : numero_(numero), user_(&user), caducidad_(caducidad) {
  2.   Fecha f_actual;
  3.   titular_ = user.nombre() + " " + user.apellidos();
  4.  
  5.   if (caducidad_ < f_actual)
  6.     throw(Tarjeta::Caducada(caducidad_));
  7.   //(&user).es_titular_de(*this);
  8. }

es decir, user tiene el modificador const.

La llamada es_titular_de tiene la firma:

Código
  1. void es_titular_de(Tarjeta&)

Es decir, no tiene el modificador const.

Cuando tu declaras una instancia como const quiere decir que, desde ese momento, no se puede modificar su estado. Esto implica que no se permiten las llamadas a métodos no const para dicha instancia.

Hasta ahí tu error. Luego hay varias cosas que no entiendo:

1. es_titular_de no tiene sentido que retorne void, es como preguntar a alguien la hora por la calle, que el otro la vea y no te responda... si lo que hace la implementación es imprimir por pantalla el resultado, mi consejo es que lo saques fuera de la clase.

Las razones son sencillas:

* La clase que contiene la función se llama Usuario, luego se presupone que su misión es gestionar la información de un usuario y no encargarse además de imprimir sus datos por pantalla, guardar los datos en un fichero y llamar a su novia en los aniversarios... responsabilidades definidas.

* Concentrar múltiples responsabilidades conlleva concentrar el código, lo que dificulta las tareas de depuración.

* El código se oscurece porque las estructuras de datos tienen a diluirse.

Tiene más sentido que la función luzca tal que

Código
  1. bool es_titular_de( const Tarjeta& ) const;

2. Tiene sentido crear instancias de "Caducada" con el constructor por defecto??

Entiendo que no, pero sin embargo, al no definir el constructor por defecto en la sección "private" se crea un constructor por defecto. Con poner solo la declaración en el archivo de cabecera vale. En C++11 también puedes impedir el uso del constructor por defecto de la siguiente forma:

Código
  1. class Caducada
  2. {
  3.   public:
  4.     Caducada( ) = delete;
  5. };

Lo mismo es aplicable a las clases Tarjeta y Usuario.

3. Esta línea

Código
  1. const Usuario * const user_; //Puntero constante al usuario dueño

te puede dar más problemas que alegrías. Sobretodo porque...

Código
  1. const Usuario* titular() const { return user_; }

Es decir, no hay ningún problema en que se modifiquen los datos del usuario.

Personalmente, dado que no hace falta que la clase cree el puntero, casi es más limpio pasar y almacenar una referencia, así evitas la "tentación" de poner un delete en un momento dado. Además, pasar clases por referencia te asegura de que la clase existe, ya que no se puede pasar un puntero a null por referencia.

Código
  1. class Tarjeta
  2. {
  3.   public:
  4.  
  5.     Tarjeta (const Numero& numero, const Usuario& usuario, const Fecha& fecha )
  6.       : user_( usuario )
  7.     { }
  8.  
  9.     Usuario& titular() const
  10.     { return user_; }
  11.  
  12.  private:
  13.  
  14.   Usuario& user_;
  15. };


4.

Código
  1. throw(Tarjeta::Caducada(caducidad_));

No es buena idea lanzar una excepción que no herede de std::exception. El motivo es que, si no heredan de std::exception, la captura por defecto es catch( ... ) y en este caso pierdes toda la información acerca de la excepción. Además, siempre es recomendable que la excepción incluya un texto descriptivo... es útil en sistemas más complejos para seguir la traza del fallo.

5.

Código
  1. titular_ = user.nombre() + " " + user.apellidos();

Este campo autocalculado no tiene demasiado sentido... nombre() y apellidos() no son llamadas a operaciones costosas, es mejor autocalcular el valor cuando sea necesario, como los puntos anteriores, no es un fallo, solo una cuestión de diseño.

6. Las clases se crean sólo si hay razón para ello

Código
  1. class Id_duplicado {
  2.   public:
  3.     Id_duplicado (const Cadena& id) : id_duplicado(id) {}
  4.     const Cadena idd() { return id_duplicado; }
  5.   private:
  6.     const Cadena id_duplicado;
  7.   };

Vista así, esta clase no aporta nada, parece totalmente prescindible. Bien es cierto que lo ideal es tener el código bien repartido en muchas clases, cada una con una única responsabilidad, y con el menor código posible... pero claro, estas clases tienen que tener una razón de ser y esta, vista así, no lo tiene. Llenar el código de clases inútiles te va a dificultar el mantenimiento de tu código y te va a dar problemas en el futuro... estás avisado.

Título: Re: Pasar 'this' como parametro
Publicado por: DvNe en 3 Abril 2014, 23:48 pm
A ver ya encontré solución a mi problema pondré todos los ficheros de mi problema ya que hace falta conocer todas las clases para ver el por qué de algunas cosas que apuntas eferion.

CLASE USUARIO JUNTO CON SU IMPLEMENTACION

Código
  1. #ifndef _USUARIO_H_
  2. #define _USUARIO_H_
  3.  
  4. #include "articulo.h"
  5. #include "tarjeta.h"
  6.  
  7. #include <istream>
  8. #include <map>
  9. #include <set>
  10. using std::map;
  11. using std::set;
  12.  
  13. class Tarjeta;
  14.  
  15. #include "cadena.h"
  16.  
  17. class Clave {
  18.  public:
  19.   enum Razon {CORTA, ERROR_CRYPT};
  20.  
  21.   class Incorrecta {
  22.   public:
  23.     Incorrecta (const Razon& r) : razon_(r) {}
  24.     Razon razon() const { return razon_; }
  25.   private:
  26.     Razon razon_;
  27.   };
  28.   Clave (const char*) throw (Clave::Incorrecta);
  29.  
  30.   Cadena clave() const { return pass_cifrada; }
  31.   bool verifica (const char*);
  32.  private:
  33.   Cadena pass_cifrada;
  34. };
  35.  
  36. class Usuario {
  37.  public:
  38.   //CONSTRUCTOR Y DESTRUCTOR
  39.   Usuario (const Cadena&, const Cadena&, const Cadena&, const Cadena&, const Clave&);
  40.   ~Usuario();
  41.  
  42.   class Id_duplicado {
  43.   public:
  44.     Id_duplicado (const Cadena& id) : id_duplicado(id) {}
  45.     const Cadena idd() const { return id_duplicado; }
  46.   private:
  47.     const Cadena id_duplicado;
  48.   };
  49.   //FUNCIONES OBSERVADORAS
  50.   Cadena id() const { return identificador_; }
  51.   Cadena nombre() const { return nombre_; }
  52.   Cadena apellidos() const { return apellidos_; }
  53.   Cadena direccion() const { return direccion_; }
  54.  
  55.  
  56.   //FUNCIONES CON TARJETAS
  57.   typedef map<Numero, Tarjeta*> Tarjetas;
  58.   void es_titular_de(Tarjeta&);
  59.   void no_es_titular_de(Tarjeta&);
  60.   const Tarjetas& tarjetas() const { return tarjetas_; }
  61.  
  62.  
  63.   //FUNCIONES CON LOS ARTICULOS
  64.   typedef map<Articulo*, unsigned> Articulos;
  65.   void compra(Articulo& articulo, unsigned cant = 1);
  66.   const Articulos& compra() const { return articulos_; } 
  67.   size_t n_articulos() const { return articulos_.size(); }
  68.  
  69.   //SOBRECARGA OPERADOR 
  70.   friend std::ostream& operator << (std::ostream&, const Usuario&); 
  71.  
  72.  private:
  73.   Cadena identificador_;
  74.   Cadena nombre_;
  75.   Cadena apellidos_;
  76.   Cadena direccion_; 
  77.   Clave password_;
  78.   Tarjetas tarjetas_;
  79.   Articulos articulos_;
  80.  
  81.   Cadena password() const { return password_.clave(); }
  82.   static set<Cadena> identificadores;
  83.   bool IdValido() const throw(Usuario::Id_duplicado);
  84.   Usuario (const Usuario&); //Deshabilitamos la copia de un usuario
  85. };
  86.  
  87. std::ostream& mostrar_carro(std::ostream&, const Usuario&);
  88. #endif

Código
  1. #include "usuario.h"
  2. #include <iostream>
  3. #include <iomanip>
  4. #include <cstring>
  5. #include <cstdlib>
  6. #include <unistd.h>
  7.  
  8. using namespace std;
  9.  
  10. Clave::Clave (const char* pass_no_cifrada) throw (Clave::Incorrecta) {
  11.   if (strlen(pass_no_cifrada) < 5) 
  12.     throw(Incorrecta(CORTA));
  13.  
  14.   srand(time(0));
  15.   const char* const validos = "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
  16.   const char salto[2] = {validos[rand() % 63], validos[rand() % 63]};
  17.   if (crypt(pass_no_cifrada,salto) == NULL)
  18.     throw(Incorrecta(ERROR_CRYPT));
  19.  
  20.   pass_cifrada = crypt(pass_no_cifrada,salto);
  21. }
  22.  
  23. bool Clave::verifica(const char* pass) {
  24.   return (strcmp(pass_cifrada.c_str(), crypt(pass,pass_cifrada.c_str())) == 0);
  25. }
  26.  
  27. set<Cadena> Usuario::identificadores;
  28.  
  29. Usuario::Usuario (const Cadena& identificador, const Cadena& nombre, const Cadena& apellidos, const Cadena& direccion, const Clave& pass) : identificador_(identificador), nombre_( nombre), apellidos_(apellidos), direccion_(direccion), password_(pass) {
  30.   IdValido();
  31. }
  32.  
  33. Usuario::~Usuario() {
  34.   for (Usuario::Tarjetas::iterator i = tarjetas_.begin(); i != tarjetas_.end(); ++i)
  35.     (*(*i).second).anula_titular();
  36.   identificadores.erase(id());
  37. }
  38.  
  39. bool Usuario::IdValido() const throw(Usuario::Id_duplicado) {
  40.   pair<set<Cadena>::iterator,bool> i;
  41.  
  42.   i = identificadores.insert(id());
  43.   if (i.second == false) {
  44.     throw(Id_duplicado(id()));
  45.     return false;
  46.   } else {
  47.     return true;
  48.   }
  49. }
  50.  
  51. ostream& operator << (ostream& output, const Usuario& user) {
  52.   output <<"\n" << user.id() << " [" << user.password() << "] " << user.nombre() << " "
  53. 	 << user.apellidos() << "\n" << user.direccion() << "\nTarjetas:\n";
  54.   for (Usuario::Tarjetas::const_iterator i = user.tarjetas().begin(); i != user.tarjetas().end(); ++i)
  55.     output << *(*i).second << "\n";
  56.   return output;
  57. }
  58.  
  59. void Usuario::compra (Articulo& articulo, unsigned cant) {
  60.   if (cant == 0) 
  61.     articulos_.erase(&articulo);
  62.   else {
  63.     if (articulos_.find(&articulo) != articulos_.end())
  64.       articulos_.erase(&articulo);
  65.       articulos_.insert(pair<Articulo*,unsigned>(&articulo,cant));
  66.     }
  67. }
  68.  
  69. ostream& mostrar_carro(ostream& output, const Usuario& user) {
  70.  
  71.   output << "Carrito de compra de " << user.id() << " [Articulos: "
  72.        << user.n_articulos() << "]\n Cant. Articulo\n================="
  73.        << "=========================================\n";
  74.   for (Usuario::Articulos::const_iterator  p = user.compra().begin(); p != user.compra().end(); p++)
  75.     output << setfill(' ') << setw(4) <<  p->second << setw(4) << *p->first << "\n";
  76.   return output;
  77. }
  78.  
  79. void Usuario::es_titular_de(Tarjeta& t) {
  80.   tarjetas_.insert(pair<Numero, Tarjeta*>(t.numero(),&t));
  81. }
  82.  
  83. void Usuario::no_es_titular_de(Tarjeta& t) {
  84.   tarjetas_.erase(t.numero());
  85. }

CLASE TARJETA Y SU IMPLEMENTACION

Código
  1. #ifndef _TARJETA_H_
  2. #define _TARJETA_H_
  3.  
  4. #include "cadena.h"
  5. #include "fecha.h"
  6.  
  7. class Usuario;
  8.  
  9. class Numero : public Cadena {
  10.  public:
  11.   enum Razon {LONGITUD,DIGITOS,NO_VALIDO}; 
  12.  
  13.   class Incorrecto {
  14.   public:
  15.     Incorrecto (const Razon& r) { razon_ = r; }
  16.     Razon razon() const { return razon_; }
  17.   private: 
  18.     Razon razon_;
  19.   };
  20.  
  21.   Numero (const Cadena&) throw (Numero::Incorrecto);
  22.   operator const char*() const {return numero_.c_str(); }
  23.  
  24.  private:
  25.   Cadena numero_;
  26.   static const unsigned LongitudMinima = 13;
  27.   static const unsigned LongitudMaxima = 19;
  28.   bool numeroValido() const ;
  29. };
  30.  
  31. bool operator < (const Numero&, const Numero&);
  32.  
  33. class Tarjeta {
  34.  public:
  35.   class Caducada {
  36.   public:
  37.     Caducada (const Fecha& f) : fecha_(f) {}
  38.     Fecha cuando() const { return fecha_; }
  39.   private:
  40.     Fecha fecha_;
  41.   };
  42.   Tarjeta (const Numero&, const Usuario&, const Fecha&) throw (Tarjeta::Caducada);
  43.   ~Tarjeta();
  44.  
  45.   Numero numero() const { return numero_; }
  46.   Fecha caducidad() const { return caducidad_; }
  47.   Cadena titular_facial() const { return titular_; }
  48.   const Usuario* titular() const { return user_; }
  49.   void anula_titular() { user_ = 0; }
  50.  
  51.   friend std::ostream& operator << (std::ostream&, const Tarjeta&);
  52.  private:
  53.   Numero numero_;
  54.   const Usuario* user_;
  55.   Fecha caducidad_;
  56.   Cadena titular_;
  57.  
  58.  
  59. };
  60.  
  61. bool operator < (const Tarjeta&, const Tarjeta&);
  62. #endif

Código
  1. #include "tarjeta.h"
  2. #include "usuario.h"
  3. #include <cstdlib>
  4. #include <cstring>
  5. #include <iostream>
  6. #include <iomanip>
  7.  
  8. using namespace std;
  9.  
  10. Tarjeta::Tarjeta (const Numero& n, const Usuario& user, const Fecha& f) throw (Tarjeta::Caducada) : numero_(n), user_(&user), caducidad_(f) {
  11.  
  12.   titular_ = user.nombre() + " " +  user.apellidos();
  13.  
  14.   Fecha f_actual;
  15.   if (caducidad_ <  f_actual) {
  16.     throw(Tarjeta::Caducada(caducidad_));return;
  17.   }
  18.   const_cast<Usuario&>(user).es_titular_de(*this);
  19. }
  20.  
  21. Tarjeta::~Tarjeta() {
  22.   Usuario* u = const_cast<Usuario*>(user_);
  23.   if (u)
  24.     u->no_es_titular_de(*this);
  25. }
  26.  
  27.  
  28. std::ostream& operator << (std::ostream& output, const Tarjeta& t) {
  29.   output << "\n  " << (const char*) t.numero() << "\n  " << t.titular_facial()
  30. 	 << "\n  Caduca: " << setfill('0') << setw(2) << t.caducidad().mes() 
  31. 	 << "/" << setw(2) << (t.caducidad().anno() % 100);
  32.   return output;
  33. }
  34.  
  35. Numero::Numero (const Cadena& numero) throw (Numero::Incorrecto) {
  36.   unsigned i = 0, j = 0, pos = 0;
  37.  
  38.   do {
  39.     pos = i;
  40.     while (i < numero.longitud() && numero[i] != ' ') { 
  41.       if (isalpha(numero[i]))
  42. 	 throw(Incorrecto(DIGITOS));
  43.       j++; i++;
  44.     }
  45.     numero_ += numero.subcadena(pos,j);
  46.     j = 0;
  47.     while (i < numero.longitud() && numero[i] == ' ') { i++; }
  48.   } while (i < numero.longitud());
  49.  
  50.   if (numero_.longitud() < LongitudMinima || numero_.longitud() > LongitudMaxima)
  51.     throw(Incorrecto(LONGITUD));
  52.   if (!numeroValido()) 
  53.     throw(Incorrecto(NO_VALIDO));
  54. }
  55.  
  56. bool Numero::numeroValido() const { //Algoritmo de Lhun
  57.   int suma = 0;
  58.   bool impar = true;
  59.  
  60.   for (int i = numero_.longitud() - 1; i >= 0; i--) {
  61.     if (!impar) {
  62.       int tmp = (numero_[i] - '0') << 1; //Multiplicamos por 2 si es impar
  63.       suma += (tmp >= 10) ? tmp - 9 : tmp;
  64.     } else 
  65.       suma += (numero_[i] - '0');
  66.     impar = !impar;
  67.   }
  68.   return (suma % 10) ? false : true;
  69. }
  70.  
  71. bool operator < (const Numero& numero1, const Numero& numero2) {
  72.   return atoll(numero1) < atoll(numero2); 
  73. }
  74.  
  75. bool operator < (const Tarjeta& t1, const Tarjeta& t2) {
  76.   return t1.numero() < t2.numero();
  77. }
  78.  
  79. std::ostream& operator << (std::ostream& output, const Numero& num) {
  80.   output << (const char*) num;
  81.   return output;
  82. }

CLASE ARTICULO Y SU IMPLEMENTACION

Código
  1. #ifndef _ARTICULO_H_
  2. #define _ARTICULO_H_
  3.  
  4. #include "cadena.h"
  5. #include "fecha.h"
  6.  
  7. class Articulo {
  8.  public:
  9.   Articulo (const Cadena&, const Cadena&, const Fecha&, const double&, const unsigned&);
  10.  
  11.   Cadena referencia() const { return codigo_Referencia; }
  12.   Cadena titulo() const { return titulo_; }
  13.   Fecha f_publi() const { return publicacion_; }
  14.   double precio() const { return precio_; }
  15.   unsigned stock() const { return ejemplares_; }
  16.  
  17.   double& precio() { return precio_; }
  18.   unsigned& stock() { return ejemplares_; }
  19.  
  20.   friend std::ostream& operator << (std::ostream&, const Articulo&);
  21.  private:
  22.   Cadena codigo_Referencia;
  23.   Cadena titulo_;
  24.   Fecha publicacion_;
  25.   double precio_;
  26.   unsigned ejemplares_;
  27. };#endif

Código
  1. #include "articulo.h"
  2. #include <iomanip>
  3.  
  4. using namespace std;
  5.  
  6. Articulo::Articulo (const Cadena& ref, const Cadena& title, const Fecha& fecha, const double& price, const unsigned& numero) : codigo_Referencia(ref), titulo_(title), publicacion_(fecha), precio_(price), ejemplares_(numero) {}
  7.  
  8. ostream& operator << (ostream& output, const Articulo& art) {
  9.   output << "[" << art.referencia() << "] \"" << art.titulo() << "\", " << art.f_publi().anno() << ". " << setprecision(2) << setfill('0') << fixed << art.precio()
  10. 	 << "\xE2\x82\xAC";
  11.   return output;
  12. }

Ahora bien la razón por la que el proyecto tiene esta implementación, es porque es un trabajo para la universidad.


Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines