[Off-Topic]
ArduMyth:
void prueba(byte &); <== ¿Y este ampersand cómo si fuese una referencia y sin variable? Piensa que esto es el parámetro que pones FUERA de la clase.
En C y C++ existe la posibilidad de declarar la existencia de funciones normales y funciones miembro de la clase antes de poner su implementación (definición completa de la función). Cuando sólo se declara no se pone "el cuerpo" de la función y en tal caso no es necesario poner el nombre de los parámetros, sólo se requiere poner el tipo. Y en este caso
** **void prueba(byte &);** **
es un claro ejemplo. Se está declarando la clase y lo que contiene. Y como en este caso se está sólo declarando la función miembro
prueba
podemos prescindir de poner un nombre de variable para el parámetro que va a recibir.
Para ilustrar lo que digo se puede compilar el siguiente ejemplo y ver que el compilador no se queja y funciona perfectamente.
void incrementa(byte &); // Declaramos que existe la función "incrementa" que tiene un parámetro de tipo "referencia a byte". Como sólo la estamos declarando no es necesario indicar el nombre del parámetro.
void setup() {
Serial.begin(9600);
byte b = 1;
Serial.print(F("Valor de b antes de incrementar: "));
Serial.println(b);
incrementa(b); // Invocamos a la función que hemos declarado al principio.
Serial.print(F("Valor de b despues de incrementar: "));
Serial.println(b);
}
void loop() {
}
// A continuación implementamos la función "incrementa" que habíamos declarado al principio.
void incrementa(byte &b) {
b++;
}
El entorno de Arduino tiene la peculiaridad de preprocesar el código antes de "enviarlo" al compilador. En "su preprocesado" detecta la necesidad de ciertas librerías y le informa al compilador de ello. A la vez que también detecta el uso de funciones en el programa antes de su implementación y antepone la declaración antes de pasarle el programa al compilador. Sin embargo, si se una alguna herramienta de compilación que no haga este trabajo, o bien implementamos la función antes de usarla (digamos que habría que ponerla al principio) o bien la dejamos "al final" pero ponemos la declaración al principio.
Como cosa curiosa y demostración de que en la declaración de la función de nada sirven los nombres de los parámetros, salvo a título informativo para el programador, se puede poner un nombre de parámetro en la declaración que nada tiene que ver con el de la implementación. Se puede cambiar sólo la primera línea del ejemplo anterior poniendo como nombre del parámetro
este_nombre_no_se_usa
quedando así:
void incrementa(byte &este_nombre_no_se_usa); // Declaramos que existe la función "incrementa" que tiene un parámetro de tipo "referencia a byte". Como sólo la estamos declarando no es necesario indicar el nombre del parámetro.
Y sin cambiar nada más podemos ver que compila y funciona exactamente igual que antes.
Recordar que, si ponemos la declaración de la función, en el código se ha de poner más tarde la implementación de la función. En el caso de
** **void prueba(byte &);** **
su implementación aparece un poco más abajo de la declaración. La implementación es:
void RTC3231::prueba(byte &prueba1)
{
puntero = &prueba1 ;
*puntero = 5 ;
}
Y por último, ya para liar más al personal (o para despertar la curiosidad de algunos). También podemos implementar una función con parámetros sin nombre. Esto sirve para sobrecargar las funciones y discernir cual se usa. Por ejemplo: podemos implementar la funcíón
incremento
dos veces más. Pero esta vez con dos parámetros. El primero es la variable a incrementar y el segundo sólo es para indicar (mediante su tipo) qué función se ha de invocar:
void incrementa(byte &); // Declaramos que existe la función "incrementa" que tiene un parámetro de tipo "referencia a byte". Como sólo la estamos declarando no es necesario indicar el nombre del parámetro.
void incrementa(byte &b, int) { // Esta no es una declaración, es una implementación completa de la función. El segundo parámetro no tiene nombre porque sólo se utiliza para sobrecargar la función "incrementa"
b += 10;
};
void incrementa(byte &b, char) { // Esta no es una declaración, es una implementación completa de la función. El segundo parámetro no tiene nombre porque sólo se utiliza para sobrecargar la función "incrementa"
b += 100;
};
void setup() {
Serial.begin(9600);
byte b = 1;
Serial.print(F("Valor de b antes de incrementar: "));
Serial.println(b);
incrementa(b); // Invocamos a la función que hemos declarado al principio.
Serial.print(F("Valor de b despues de incrementar: "));
Serial.println(b);
incrementa(b, 0); // Invocamos a la función que tiene dos parámetros (el segundo parámetro es de tipo int)
Serial.print(F("Valor de b despues volver a incrementar: "));
Serial.println(b);
incrementa(b, 'x'); // Invocamos a la función que tiene dos parámetros (el segundo parámetro es de tipo char)
Serial.print(F("Valor de b despues de otro incremento: "));
Serial.println(b);
}
void loop() {
}
// A continuación implementamos la función "incrementa" que habíamos declarado al principio.
void incrementa(byte &b) {
b++;
}
Como se podrá observar, el segundo parámetro no se usa dentro de la función. Por lo que no es necesario ponerle un nombre.
Esto último, lo de usar parámetros sólo por su tipo para sobrecargar las funciones, es algo que sólo tiene sentido en muy pocas ocasiones y que sólo usan "programadores avanzados". Pero lo de declarar las funciones sin poner el nombre de los parámetros para después poner su implementación es algo que sí se suele ver. Personalmente prefiero poner siempre los nombres (con algo de sentido) ya que ayudan a leer y comprender el código.
Perdón por el Off-Topic.