Clases y Objetos

Un paradigma es el resultado de un proceso social en el cual un grupo de personas desarrolla nuevas ideas y crea principios y prácticas alrededor de estas ideas, resumiendo: un paradigma es una metodología de trabajo.

En programación, se trata de un enfoque concreto de desarrollar y estructurar el desarrollo de programas.

Paradigma imperativo

  • Consiste en una secuencia de instrucciones que el ordenador debe ejecutar.
  • Los elementos más importantes en esta forma de programar son:
    • Variables, zonas de memoria donde guardamos información.
    • Tipos de datos, son los valores que se pueden almacenar.
    • Expresiones, corresponde a operaciones entre variables (del mismo o distinto tipo)

Paradigma funcional:

  • Consiste en el uso de funciones que realizan su tarea como si de una caja negra se tratase
  • Pese a que trabajamos con funciones, el modelo desarrollado hasta ahora con Arduino no verifica todos los requisitos del paradigma de programación funcional ya que, en nuestro caso existe el concepto de variable, que no se da en programación funcional. 

Paradigma orientado a objetos:

  • Es el más popular en la actualidad.
  • Se fundamenta en la “fusión” de datos y funciones que operan sobre esos datos dentro de un nuevo tipo de dato.
  • Al nuevo tipo de dato se le llama CLASE.
  • A cada variable de una clase se le llama OBJETO.

Propiedades del paradigma orientado a objetos

  • Encapsulamiento
    • Significa que los datos pertenecen a un objeto (espacio de nombres del objeto).
    • Podemos ir más allá y ocultar los datos de un objeto a cualquier otro objeto o código que trate de hacer uso de ellos. Serían sólo accesibles al propio objeto y, en algunos casos, a objetos de sus clases descendientes.
  • Herencia:
    • Es la propiedad de crear nuevos datos a partir de un objeto
  • Una clase es un nuevo tipo de dato. Contiene :
    • otros datos (que pueden ser de cualquier tipo)
    • Funciones, que operan sobre esos datos.

Las variables incluidas en una clase se denominan ATRIBUTOS.

Las clases pueden contener funciones. A éstas se les denomina MÉTODOS.

Una vez definida la clase, crear un objeto es tarea sencilla. Basta con ejecutar la instrucción de asignación: objeto = Nombre_clase ()

Programación Orientada a Objetos

La programación orientada a objetos (POO, u OOP según sus siglas en inglés) es un paradigma de programación que viene a innovar la forma de obtener resultados. Los objetos manipulan los datos de entrada para la obtención de datos de salida específicos, donde cada objeto ofrece una funcionalidad especial.

La modularidad es la capacidad de dividir el problema en pequeñas partes independientes entre sí, esto va más allá de la encapsulación de un simple procedimiento de la programación estructurada que hemos visto hasta ahora. Aquí se encapsula un conjunto de operaciones y datos que tienen mucha relación entre sí formando un módulo.

Un lenguaje basado en objetos nos da la posibilidad de definir objetos y realizar operaciones sobre ellos y es similar al paradigma de abstracción de datos. La adición de de los conceptos de de clases y herencia nos hace hablar de lenguajes orientados a objetos. Un objeto es la instancia de una clase.

Mediante la herencia podemos reutilizar el comportamiento de una clase en la definición de nuevas clases.

Muchos de los objetos pre-diseñados de los lenguajes de programación actuales permiten la agrupación en bibliotecas o librerías, sin embargo, muchos de estos lenguajes permiten al usuario la creación de sus propias bibliotecas.

Está basada en varias técnicas, incluyendo herencia, cohesión, abstracción, polimorfismo, acoplamiento y encapsulamiento.

Los objetos son entidades que tienen un determinado “estado”, “comportamiento (método)” e “identidad”:

  • La identidad es una propiedad de un objeto que lo diferencia del resto; dicho con otras palabras, es su identificador (concepto análogo al de identificador de una variable o una constante).
  • Los métodos (comportamiento) y atributos (estado) están estrechamente relacionados por la propiedad de conjunto. Esta propiedad destaca que una clase requiere de métodos para poder tratar los atributos con los que cuenta.

Una clase es una plantilla para la creación de objetos de datos según un modelo predefinido. Las clases se utilizan para representar entidades o conceptos. Cada clase es un modelo que define un conjunto de variables (el estado), y métodos apropiados para operar con dichos datos (el comportamiento). Cada objeto creado a partir de la clase se denomina instancia de la clase.

Las clases son un pilar fundamental de la programación orientada a objetos. Permiten abstraer los datos y sus operaciones asociadas al modo de una caja negra. Los lenguajes de programación que soportan clases difieren sutilmente en su soporte para diversas características relacionadas con clases. La mayoría soportan diversas formas de herencia.

C++ está diseñado para la programación orientada a objetos (POO), y en ese paradigma, todas las entidades que podemos manejar son objetos. Los punteros en C++ sirven para señalar objetos, y también para manipularlos.

La OOP tiene tres características básicas que se suelen presentar como Encapsulación, Polimorfismo y Herencia.

  • La encapsulación es un procedimiento por el cual, los datos y las funciones se encierran en un contenedor llamado objeto, que usamos para aislar ambos elementos de la manipulación exterior y forzar a que esta se haga de un modo controlado y validado por nosotros mismos. El mecanismo que C++ utiliza para encapsular estos objetos se llaman clases.
  • Se suele definir el polimorfismo como: Un interface único, múltiples métodos. Y es algo que reduce la complejidad de los programas de una forma notable. A usar las funciones u operadores de diferentes maneras dependiendo del tipo de los datos, le llamamos polimorfismo y cuando redefinimos un operador o función para comportarse de forma diferente con esos datos, decimos que el operador esta sobrecargado (Overloaded)- Por ejemplo en C++ podemos sumar números enteros o números float con el mismo símbolo “+”, y nos parece tan normal, pero en realidad los procedimientos que se aplican son completamente distintos.
  • La herencia es un proceso por el cual un objeto hereda las propiedades y métodos de otro, sin necesidad de volverlas a definir desde el principio.

Más información: http://www.alegsa.com.ar/Dic/programacion_orientada_a_objetos.php

Ejemplo de uso de un objeto: Imaginemos que hemos hecho un coche coche controlado por bluetooth y tenemos 5 botones para las 4 direcciones y parar. Creamos una clase llamada ‘Coche’ que se inicializa con los pines donde conecto los dos motores del coche.

#include “Coche.h”

Coche MiCocheRC(6,7)	//Construyo el objeto poniendo los pines de los motores

void setup() {
MiCoche.Arranca()
}

void loop() {
char valor = leeBluetooth();

switch (valor) {
    case ‘F’:
      MiCoche.Adelante();
      break;
    case ‘R’:
      MiCoche.Derecha();
      break;
    case ‘L’:
       MiCoche.Izquierda();
      break;
    case ‘B’:
       MiCoche.Atras();
      break;
    case ‘S’:
       MiCoche.Para();
      break;
  }
}

Dentro del fichero ‘Coche.h’ se define la clase y las variables y métodos. Dentro del fichero ‘Coche.cpp’ está el código para mover los motores según cada una de las 5 funciones que he definido.

La función leeBluetooth() simplemente lee valores que llegan por el puerto serie al que está conectado el bluetooth.

Para llamar a los métodos de un objeto y en función de cómo esté construida la librería se puede hacer de varias formas:

Más información sobre clases y objetos:

Clases y Objetos en Arduino

Antes de que empecemos a hablar sobre Clases y Objetos, es importante insistir en que, la OOP no es tanto un lenguaje de programación diferente, sino más bien, una manera diferente de organizar tus programas y tus ideas, de acuerdo con unos principios guía que nos permiten modelar nuestro código de un modo distinto a como lo hemos hecho hasta ahora.

Para definir las Clases, existen una serie de reglas y de nuevas instrucciones, pero por lo demás el lenguaje sigue siendo el de siempre.

Si queremos hacer un contador en Arduino, creamos una variable global llamada “contador”. Pero esto ilustra bastante bien el problema de que si quiero 6 contadores voy a necesitar 6 variables globales. La idea en OOP es crear una Clase que nos permita definir Objetos tipo Contador que se pueda reutilizar y que nos permita mezclar diferentes contadores en un mismo programa.

Una de las ideas básicas tras la OOP es encapsular los datos y las funciones (o propiedades y métodos) de nuestro programa en un contenedor común, y más importante aún, aplicamos el principio de: “Esconder los datos y mostrar los métodos o funciones”.

Cuando definimos Clases, veremos que hay partes que son públicas y otras que son privadas. La sintaxis para definir la Clase contador que nos ocupa:

class Contador{
  private:
    int N;
 
  public:
    void SetContador( int n){
      N = n;
    }
 
    void Incrementar(){
      N++;
    }
 
    int GetCont(){
      return (N);
    }
};

Debajo de la cláusula “private:” viene las variables y funciones ocultas al exterior. Solo pueden ser invocadas desde el interior de la clase, es decir no se pueden ejecutar por una llamada exterior. Y lo contrario ocurre con lo que definamos tras la cláusula “public:”

Vamos a definir una variable privada llamada N, que llevará la situación del contador, y después necesitaremos los métodos necesarios para trabajar con ella. En principio vamos a definir tres funciones públicas: Una que ponga el contador a un valor dado antes de nada, Otra que sirva para incrementar el contador, y otra tercera para que nos entregue el valor del contador en un momento dado.

La variable N se comporta como si fuera una variable global pero sólo dentro del ámbito de la Clase (Encapsulación), y como está definida como private es inaccesible desde el exterior (Cualquier intento de llegar a ella causará un error del compilador)

Para usar esta clase, primero se instancian tantas ocurrencias de la clase como queramos. 

#include "Contador.h"

Contador C1,C2;

void setup()
   {
      C1.SetContador(10);
      C2.SetContador(100);
   }

void loop()
   {
      C1.Incrementar() ;
      Serial.print("C1 = ") ; Serial.println(C1.GetCont());
 
      C2.Incrementar() ; C2.Incrementar() ; C2.Incrementar();
      Serial.print("C2 = ") ; Serial.println(C2.GetCont());
   }

Constructures

Usamos el “.” para referir la función a la que queremos llamar, con el Objeto al que se le aplica, como hemos visto antes en otros programas aunque sin entrar en muchos detalles.

Podemos definir una función que se ejecuta siempre que se crea un objeto, y es tan habitual que tiene nombre. Se le llama Constructor de la Clase, y para ello basta con llamarla igual que la Clase (Sin tipo):

 
Class Contador{
  private:
    int N;  
 
  public:
    Contador( ){    	// Constructor
      N = 0;
    }
  
    void SetContador(int n){
      N = n;
    }
 
    void Incrementar(){
      N++;
    }
 
    int GetCont(){
      return(N);
    }
};

Una peculiaridad de los constructores es que no tienen un tipo definido, otra de las razones por las que el compilador sabe que es un constructor.

En este caso cuando hago Contador C1,C2 ; ya está inicializado el contador a 0 que lo hace el propio constructor.

Ficheros Cabecera (Header)

Cuando las clases y las funciones miembro son tan pequeñas y sencillas como en este caso, la forma que hemos visto de definirlas puede valer, pero en seguida se quedará corta. Por eso podemos declarar las funciones y variables miembros en la declaración de Clase, y definirlas fuera para mayor comodidad y evitar errores de sintaxis complicados de detectar.

Podemos reescribir la clase Contador así:

Fichero “Contador.h”:

 
class Contador
   {  private:
         int N ;

      public:
         Contador( ) ;               	// Constructor
         void SetContador( int n) ;  	// Declaracion de funcion externa
         void Incrementar() ;        	// Declaracion de funcion externa
         int GetCont() ;             	// Declaracion de funcion externa
   } ;

Fichero “Contador.cpp”:

 
#include <Contador.h>
 
  void Contador::SetContador( int n)
        {  N = n ;	}

   void Contador::Incrementar()
        {  N++ ; }
 
   int Contador::GetCont()
        { return (N) ;}

Declaramos las funciones miembros dentro de la Clase (Para informar al compilador), pero no incluimos su código aquí, porque sería muy confuso en cuanto crezcan de tamaño (Pero fijaros que ahora hay un punto y coma al final de las declaraciones que antes no había en el fichero header).

En cualquier otro lugar podemos definir esas funciones sin más que hacer referencia a la Clase a la que pertenecen usando el operador ‘::’ (Scope Operator u Operador Ámbito) y el compilador entiende que son miembros de la clase que precede al operador. Este operador le indica al compilador, que estas funciones o variables son miembros de la clase, y sólo pueden invocarse de acuerdo a las condiciones que se especifican en la declaración de la Clase (Que debe coincidir con esta, claro está).

Si editais cualquiera de las librerías de Arduino, encontrareis que ésta es la forma habitual de programar las clases y librerías.

Cuando declaramos una propiedad miembro de una clase como static, el compilador crea una única variable para ella, que es compartida por todas las instancias de los objetos de esa Clase, rompiendo así la regla de que cada instancia tiene su propio juego de memoria y propiedades.

Polimorfismo y Sobrecarga

El polimorfismo podemos verlo en la clase Serial:

 
Serial.println(5) ;
Serial.println(3.1416 ) ;
Serial.println(“Buenos días”) ;

Según lo que hemos aprendido hasta ahora, una función solo puede aceptar un tipo definido de parámetros.  Es una característica inherente a C++ y que no existía en C, y no es otra que una característica llamada function overloading.

Gracias al Polimorfismo los println() anteriores funcionan, aunque todo indica que no deberían, porque va en contra de todo lo que hemos aprendido hasta ahora de las funciones. El misterio está en que no existe una única función println(), sino que las líneas anteriores invocan 3 funciones completamente diferentes… que se llaman igual.

Hacer un Overloading del Constructor, en la clase contador

 
class Contador
   {  private:
         int N ;

      public:	
         Contador( ) ;           	// Constructor
         Contador( int k ) ;     	// Constructor
         void SetContador( int n) ;
         void Incrementar() ;
         int GetCont() ;
   } ;

Contador::Contador( )          	// Constructor
    { N = 0 ; }       
Contador::Contador( int k)         // Constructor
    { N = k ; }   

Contador C1, C2(23) ;

Así podemos instar un objeto sin una variable y el contador empieza en 0 o con una variable entera y el contador empieza con ese valor. Hemos hecho un Overloading del Constructor de la Clase.

El function Overloading es un aspecto del Polimorfismo que nos permite manejar diferentes objetos con los mismos métodos o propiedades. El Polimorfismo es una cualidad abstracta de los objetos que nos permite usar un interface único, de métodos y propiedades, en una colección de objetos de distintos tipos o Clases.

Operadores

No solo se pueden sobrecargar las funciones, sino también los operadores para que hagan cosas diferentes en función del tipo de los operadores. De hecho, cuando definimos una nueva Clase, lo que estamos haciendo es crear un nuevo tipo de datos, tipo en el sentido de int, long, etc. y dentro de cada clase podemos hacer el Overloading de los operadores que nos interesen, para indicarle al compilador, cómo debe ejecutarse la operación que representa el símbolo del operador.

 
class Contador
   {  private:
         int N ;

      public:
         Contador( ) : N(0) {}    	            // Constructor
         Contador(int k ) : N(k) {}           	// Constructor
         void SetContador( int n) ;
         int GetCont() ;
         void operator ++ ();                     	// Aqui esta ++
   } ;

void Contador::SetContador( int n)  {  N = n ;	}
int  Contador::GetCont() { return (N) ;}
void Contador::operator ++ ()                     	//  <---
     {  ++N }

Usamos la keyword “operator”, para identificar el operador a definir y la definimos como void porque no devolvemos nada, simplemente incrementamos su valor. Ahora podemos hacer:

 
Contador C1(10)  ;
++C1 ;
Serial.println(C1.GetCont());

Para cada objeto declarado de una clase se mantiene una copia de sus datos, pero todos comparten la misma copia de las funciones de esa clase. Esto ahorra memoria y hace que los programas ejecutables sean más compactos, pero plantea un problema. Cada función de una clase puede hacer referencia a los datos de un objeto, modificarlos o leerlos, pero si sólo hay una copia de la función y varios objetos de esa clase, ¿cómo hace la función para referirse a un dato de un objeto en concreto?

La respuesta es: usando el puntero especial llamado this. Se trata de un puntero que tiene asociado cada objeto y que apunta a si mismo. Ese puntero se puede usar, y de hecho se usa, para acceder a sus miembros.

El operador “this” es un puntero que se pasa a disposición de todas las funciones miembro de la clase, (Y eso incluye a todas los funciones de operadores sobrecargados), que apunta al objeto al que pertenecen. Cuando instanciamos C1, cualquier función miembro que reclame el operador this, recibe un puntero a la dirección de memoria que almacena sus datos, que por definición es una la dirección del objeto C1.

 
const Contador &Contador::operator ++()
    { ++N;
      return *this ;
    }

Definimos la función operator ++ como tipo Contador porque va a devolver un objeto de este tipo. La particularidad está en que avisamos al compilador con el símbolo &, de que lo que vamos a devolver es un puntero a un objeto de la clase Contador, y no un objeto. Tras incrementar N, ya hemos realizado la operación que buscábamos y el objeto presente, por ejemplo C1, ya tiene el valor adecuado. Y ahora devolvemos el puntero a nuestra propia instancia del Objeto con la referencia que indica el operador this y de ese modo nos ahorramos el trasiego de crear y eliminar objetos temporales. Lo de especificar la función como const, es para evitar que al pasar la referencia de nuestro objeto actual, haya posibilidad de modificarlo por error.

Sumar contadores, podemos sumar los registros internos de dos contadores, de modo que el resultado sea otro contador con un valor de N interno igual a la suma de los dos operandos. No sería complicado definir una función miembro, que podemos llamar Suma, que devuelva un objeto Contador tras operar con dos contadores. Podríamos hacer algo así:

 
Contador  Contador::Suma( const Contador & C1 ) 
      {   return Contador  ( N + C1.GetCont() ) ; }

Aunque este método funcionará, su uso es un poco extraño :

 
Contador C1(), C2(23) ;
Contador C3 = C1.Suma(C2) ;

Pero si queremos escribir la suma así: Contador C3 = C1 + C2 ;  para eso está la sobrecarga de operadores binarios.

 
class Contador
  {   private:
     	int N ; 

  	public:
     	Contador( ) : N(0) {}                 // Constructor
     	Contador(int k ) : N(k) {}            // Constructor
     	void SetContador( int n) ;
     	int GetCont() ;                 
     	const Contador &operator ++ ();
     	Contador operator ++ (int) ;
         Contador operator + (  Contador &) ;  // Pasamos una referencia a un contador
  } ;

Contador  Contador::operator + (  Contador & C1 )
       	{ return Contador  (  N + C1.GetCont() ) ; }

Herencia

La herencia es la reusabilidad del código. Supongamos que ya tenemos probada y depurada la clase Contador y que ahora necesitamos una Clase nueva que en vez de ir creciendo sin fin sea un descontador, para que haga cuentas a cero desde el número que le damos, como para lanzar un cohete.

Podemos coger el código fuente de contador y modificarlo para incluir un decrementador del mismo, pero también podemos hacer uso de la herencia para que la nueva clase herede de la anterior. El método es derivar una nueva clase de una que ya existe. Esto hace que la clase derivada herede todas las características y métodos de la Clase Base sin tocarla y ahora podamos añadir lo que nos interese, garantizando que la Clase original permanece inalterada.

Queremos definir una nueva clase que se llame CountDown derivada de Contador y añadirle una función de decremento. Para ello lo primero es ver cómo derivamos una clase de otra. La sintaxis es esta:

 
Class CountDown :  public Contador          // Es una clase derivada
   {   public:
       	Counter Operator –()
           	{ return Counter(--N) ; 
   }

En la primera línea declaramos una nueva clase CountDown que deriva de Counter y es de acceso público, y después definimos un prefix operator para decrementar la variable interna. Aunque la sintaxis es buena, el compilador no tragaría con esto. Si te fijas en la definición de Contador, hemos definido N, el contador interno, como private, y eso significa que no permitirá el acceso a ninguna función externa a la clase Contador (Incluido CountDown), lo que nos hace imposible acceder desde la nueva clase derivada.

Para que podamos acceder a propiedades o métodos internos desde clase derivadas (Pero no desde cualquier otro medio), necesitamos definirlo no como private, sino como protected en la clase base:

 
class Contador
   {  protected:                    	// Aqui esta el truco
         int N ;
   
      public:
     	Contador( ) : N(0) {}      	// Constructor
     	Contador(int k ) : N(k) {} 	// Constructor
   
         int GetCont() 
        	{ return (N) ;      }
     
     	Contador operator ++()
     	  {  return Contador( ++N) ;	}
   } ;

Al definir N como protected, significa que podemos acceder a esta variable desde clases derivadas de ella, pero sigue siendo imposible acceder desde un programa externo. A esta capacidad de acceder a los miembros públicos o protected de una clase se le conoce genéricamente por accesibilidad.

 
void loop()
   { CountDown C1 ;
     ++C1; ++C1; ++C1;
     Serial.println (C1.GetCont()) ;

     --C1 ; --C1 ;
     Serial.println (C1.GetCont()) ;
   }

Una clase derivada hereda los  métodos y propiedades, de la clase original, (Que sean public o private, claro) y podemos usarlas sin problema, lo que le confiere una potencia inusitada para definir jerarquías conceptuales.

El compilador puede usar un constructor por defecto sin parámetros, pero cualquier otro debe ser definido en la clase derivada independientemente y no puedo usar CountDown C1(25) ;

 
class CountDown : public Contador
  {   public:
         CountDown( )  :  Contador() {}     	// Constructor
         CountDown(int k )  :  Contador(k) {}

         Contador operator -- ()
            {  return Contador( --N) ;       }
  } ;

Donde simplemente le especificamos al compilador que use los constructores disponibles en  la clase base (O definir unos completamente nuevos), y así podamos crear C1 con un valor especificado. Donde especificamos al compilador que cuando se cree una instancia de CountDown, debe invocar el constructor de la clase base que le indicamos. La primera podríamos omitirla porque ya sabemos que el compilador proporciona un constructor por defecto, pero es buena política definirlo aquí para evitar sobresaltos.

Function Overriding

Hemos visto que podemos definir nuevos constructores porque el compilador no aplicará per se más que el default constructor sin parámetros, y también  hemos visto que las funciones disponibles en la clase original están gentilmente a disposición de las clases derivadas, pero puede ocurrir que nos interese redefinir una de ellas para que funcione de otra manera en la nueva clase derivada. A esta capacidad de redefinir una función miembro con el mismo nombre se le llama Function Overriding.

Podemos forzar un Override de la función miembro GetCont (), en nuestra clase CountDown para hacer que nos devuelva el doble del valor interno del contador.

 
class CountDown : public Contador
   {  public:
         CountDown( ) : Contador() {}     	// Constructor
         CountDown(int k ) : Contador(k) {}

         Contador operator -- ()
             {   return Contador( --N) ;	}

         int GetCont()
             {   return(2*N) ; }
   } ;

En donde simplemente creamos una nueva función miembro de CountDown con el mismo nombre y distinta ejecución.

Destructores

Los destructores son funciones miembro especiales que sirven para eliminar un objeto de una determinada clase. El destructor realizará procesos necesarios cuando un objeto termine su ámbito temporal, por ejemplo liberando la memoria dinámica utilizada por dicho objeto o liberando recursos usados, como ficheros, dispositivos, etc.

Al igual que los constructores, los destructores también tienen algunas características especiales:

  • También tienen el mismo nombre que la clase a la que pertenecen, pero tienen el símbolo ˜ delante.
  • No tienen tipo de retorno, y por lo tanto no retornan ningún valor.
  • No tienen parámetros.
  • No pueden ser heredados.
  • Deben ser públicos, no tendría ningún sentido declarar un destructor como privado, ya que siempre se usan desde el exterior de la clase, ni tampoco como protegido, ya que no puede ser heredado.
  • No pueden ser sobrecargados, lo cual es lógico, puesto que no tienen valor de retorno ni parámetros, no hay posibilidad de sobrecarga.

Cuando se define un destructor para una clase, éste es llamado automáticamente cuando se abandona el ámbito en el que fue definido. Esto es así salvo cuando el objeto fue creado dinámicamente con el operador new, ya que en ese caso, cuando es necesario eliminarlo, hay que hacerlo explícitamente usando el operador delete. En general, será necesario definir un destructor cuando nuestra clase tenga datos miembro de tipo puntero, aunque esto no es una regla estricta.

Ejemplo:

 
#include <iostream>
#include <cstring>
using namespace std;
 
class cadena {
  public:
   cadena();        // Constructor por defecto
   cadena(const char *c); // Constructor desde cadena c
   cadena(int n);   // Constructor de cadena de n caracteres
   cadena(const cadena &);   // Constructor copia
   ~cadena();       // Destructor

   void Asignar(const char *dest);
   char *Leer(char *c);
  private:
   char *cad;       // Puntero a char: cadena de caracteres
};
cadena::~cadena() {
   delete[] cad;        // Libera la memoria reservada a cad
}

Más información:

Clase Serial Arduino

Un ejemplo de clase es una que usamos habitualmente, la clase Serial: https://www.arduino.cc/en/Reference/Serial que está definida en los ficheros:

Por lo tanto cuando estamos Serial.begin(9600) estamos llamando al método begin del objeto Serial. En este caso no hemos hecho un include del fichero donde está incluida esta clase porque el IDE lo incluye automáticamente en el proceso de compilación ni tampoco hacemos una declaración del objeto con el constructor, puesto que también lo hace el IDE de Arduino.

Si vemos los ficheros donde está la clase HardwareSerial, vemos que se  trata de una clase heredada de la clase base Stream (class HardwareSerial : public Stream). La clase Stream está definida en el reference de Arduino en https://www.arduino.cc/en/Reference/Stream que es la clase de la que heredan otras clases como Serial, Wire, Ethernet Client, Ethernet Server y SD.

Vemos que los métodos de la clase Stream son los mismo que para Serial, Ethernet, etc… y por lo tanto nos es más fácil entender las clases derivadas si entendemos la clase base.

Un ejemplo de function overriding lo vemos con el método flush() que en la clase Stream sun función el limpiar el buffer una vez que todos los caracteres han sido enviados, pero en el caso de la clase derivada Serial, el método flush() lo que hace es esperar a la transmisión de todos los caracteres hasta su finalización.

La clase base Stream está definida en los ficheros:

De la librería Stream heredan muchas otras librerías https://www.arduino.cc/en/Reference/Stream

Anuncios

Un pensamiento en “Clases y Objetos

  1. Pingback: Saber Más Programación Arduino 2019 | Aprendiendo Arduino

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión /  Cambiar )

Google photo

Estás comentando usando tu cuenta de Google. Cerrar sesión /  Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión /  Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión /  Cambiar )

Conectando a %s

This site uses Akismet to reduce spam. Learn how your comment data is processed.