[C con Clase] operador "<<"

[Steven Davidson]

Hola José Luis,

2011/11/27 jose luis <jcmdustin en gmail.com>:
> Hola amigos... hace poco estube haciendo un programa para un profesor y encontre el siguiente ...
>

Israel ya te ha contestado, pero sólo quiero mencionar algunos
problemas de diseño que he visto con esta clase.

> const int MAXCANAL = 80 ; // numero maximo de canal
> const int MAXVOLUMEN = 10 ; // nivel maximo de volumen

Deberías definir estas constantes dentro de la clase 'televisor', que
es quien usa esta información. Esto sería,

class televisor
{
public:
  static const int MAXCANAL;
  static const int MAXVOLUMEN;
  ...
};

const int televisor::MAXCANAL = 80;
const int televisor::MAXVOLUMEN = 10;

> class televisor{
> private:
>    char marca[15] ;    // marca del televisor
>    int canal ;         // numero de canal que esta sintonizando
>    int volumen;        // nivel de volumen del televisor
>    bool estado;        // false: apagado, true; prendido

Recomiendo definir constantes para dejar bien establecido los valores
para "estado". Por ejemplo,

class televisor
{
public:
  static const bool PRENDIDO;  // o como lo escribiría yo :)  ENCENDIDO
  static const bool APAGADO;
  ...
};

const bool televisor::PRENDIDO = true;
const bool televisor::APAGADO = !televisor::PRENDIDO;

Así podemos usar estas constantes al usar los objetos de 'televisor'.

> public:
>    televisor () ;
>    televisor ( char m[15], int c, int v, bool e) ;
>    televisor ( televisor &t) ;

Acostúmbrate a usar 'const' para los parámetros que sean arrays,
punteros, o referencias y que sirvan para entregar información. Esto
sería,

  televisor( const char m[15], int c, int v, bool e );
  televisor( const televisor &t );

>    ~televisor () ;
>    void getmarca () ;

Esta función miembro realmente no debería estar. Si quieres mostrar
información a la pantalla, crea una función global que use la interfaz
pública de esta clase, a modo de función auxiliadora, pero no como una
función miembro perteneciente a la interfaz pública de 'televisor'. No
es muy lógico.

Lo que sí deberías hacer es que 'getmarca()' retornase la cadena de
caracteres. Como no quieres permitir que "alguien externo" modifique
esta información, indica que es 'const'. Por ejemplo,

const char *getmarca() const;

>    int getcanal () ;
>    int getvolumen () ;

Estas dos funciones miembro también deberían ser funciones constantes,
ya que no tienen ninguna intención de modificar el estado de "este
objeto".

>    void operator * () ;        // prender o apagar el televisor
>    void operator ++ () ;       // cambia de canal al siguiente
>    void operator -- () ;       // cambia de canal al anterior

No aconsejo que estos operadores no retornen nada. Deberían retornar
"este objeto" ya modificado. Por ejemplo,

televisor &operator*();
televisor &operator++();
televisor &operator--();

televisor &operator*()
{
  estado = !estado;
  return *this;
}

De esta manera, podemos "encadenar" operaciones. Por ejemplo,

televisor mitele( "Samsung", 1, televisor::MAXVOLUMEN*2/3, televisor::APAGADO );

cout << (++*mitele).getvolumen() << endl;

Si los operadores no retornan nada, entonces no podrías hacer esto,
sino operar en cada sentencia; o sea,

*mitele;
++mitele;
cout << mitele.getvolumen() << endl;

Esto es un poco engorroso, creo yo.

>    void cambiar (int c) ;      // cambiar al canal c
>    void operator + (int n) ;   // aumenta el volumen n niveles
>    void operator - (int n) ;   // disminuye el volumen n niveles

Nuevamente, sugiero retornar una referencia a "este objeto".

>    friend bool operator == (televisor x, televisor y) ; // compara

Deberías usar 'const televisor &' para pasar objetos que no vayan a
ser modificados. Te ahorras memoria y tiempo de ejecución.

> };


Espero que esto te sirva.

Steven