Referencias (programación) .

Son un tipo de dato estrechamente relacionado

con los punteros. Una referencia de un objeto no es un objeto, en el sentido que no
tiene su propio espacio de almacenamiento como ocurre con los punteros, y en
consecuencia no pueden realizarse con ellas muchas de las operaciones que se
relacionan con objetos. Por ejemplo obtener su dirección, crearlas con el operador
nuevo, o crear matrices de referencias.

Una referencia es una especie de alias o "alter ego" del objeto. Es un recurso para
pasar argumentos a funciones permitiendo que los argumentos no sean simples
variables locales de la función, sino objetos del ámbito que realiza la invocación, lo
que permite que la función pueda modificar objetos externos a ella.

Sintaxis:
La declaración de una variable de este tipo se realiza mediante el declarador de
referencia. La sintaxis general es: <tipo_objeto> & <etiqueta_referencia> [=
<iniciador>] Ejemplo: int x; ... int & z = x; // decimos que x es el 'iniciador' y que z es
la 'referencia' Estas sentencias declaran e inicia la variable z como referencia-a-
entero, y la asocia con la variable x (que es un entero). En adelante z actúa como
un alias de x, de forma que cualquier operación sobre z equivale a hacerla sobre x.
En realidad puede considerarse que z es "casi" un sinónimo de x (como si fuesen
la misma variable).

Observaciones
En muchas situaciones prácticas puede ser indiferente utilizar una referencia o un
puntero, sin embargo mantienen importantes diferencias que conviene conocer y
que resumimos en el cuadro adjunto antes de comentarlas más detenidamente. En
cualquier caso, la mejor regla es recordar que las referencias pueden considerarse
como un sustituto del identificador de un objeto, mientras que los punteros deben

Clases y Objetos
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:
1 class Contador{

  private:
2

3     int N;

4  

5   public:

6     void SetContador( int n){

      N = n;
7
    }
8
 
9
    void Incrementar(){
10
      N++;
11
    }
12
 
13     int GetCont(){
14       return (N);

15     }

16 };

17
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.
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):
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.
Ejercicio: Hacer un programa que cuente las pulsaciones de los botones A y B usando la
clase contador guardada en un fichero “Contador.h”
Solución: https://github.com/jecrespo/aprendiendoarduino-
Curso_Programacion_Arduino/tree/master/Ejercicio11-Clase_Contador
Ver que necesito dos funciones detecta flanco y no puedo usar solo una porque si llamo a
una y a otra simultáneamente el valor static se mantiene entre la llamada de una y otra lo
que hace que falle. Para resolver este problema, hacer una clase DetectaFlanco y
entonces puedo reutilizar el código ya que cada vez que instancio una nueva clase es
como una función nueva.
Ejercicio: Hacer el programa anterior pero creando  una clase llamada DetectaFlanco en
un fichero “DetectaFlanco.h”