declarar variables

International Español Software
1

Pues después de terminar un programita, me puse a la tarea de escribir todos los argumentos, y en un impulso de hermosear el sketch, a la hora de declara variables, por ejemplo:

boolean Var1 = true;
boolean Var2 = true;
boolean Var3 = true;

Puse lo siguiente:

boolean Var1, Var2, Var3 = true;

Y en los condicionales que utilizan el valor true de la variable, pues no entran, debí volver a declararlas como estaban.

La pregunta viene porque he declarado un montón de variables de la misma forma, y parece que no dan error, por ejemplo:

byte Var1, Var2, Var3, Var4 = 0;

unsigned long MillisPrevias1, MillisPrevias2, MillisPrevias3, MillisPrevias4, MillisPrevias5 = millis();

Pero lo mismo estoy equivocándome, he buscado pero no he encontrado nada que me aclare, ¿Hay reglas para declararlas en grupo?

2

Es facil, lo estabas haciendo bien (casi), solo tienes que condicionar todos los valores:

  • byte Var1 = 0, Var2 = 0, Var3 = 0, Var4 = 0;*
  • unsigned long MillisPrevias1= millis(), MillisPrevias2= millis(), MillisPrevias3= millis(), MillisPrevias4 = millis(), MillisPrevias5 = millis();*

Nota para el moderador: se que hay q poner lo de code, pero es una tontería el fallo y creo q lo verá mejor si lo pongo en rojo. (Como sugerencia, estaría guay poder cambiar el color al código, y así facilitar ver lo que has cambiado)

3

Gracias, entonces si las inicializo sin asignarles un valor, supongo que es correcto lo siguiente:

int Var1, Var2, Var3;
4

Si, es correcto. :wink:

5

Sí, es correcto declarar variables así:

int Var1, Var2, Var3;

... pero es poco recomendable, a no ser que estés seguro de que se van a inicializar posteriormente, antes de ser "usadas". Aunque es probable que la RAM del Arduino se inicialice con ceros al arrancar (o que el "subsistema" de Arduino lo haga). Pero también es probable que no.

Aún así, el que inicialmente toda la RAM esté a cero, sólo nos evitaría que las variables globales y estáticas se "inicializaran con basura". Pero las variables locales de una función no tienen porqué inicializase a cero si no se le especifica y el compilador no está configurado para "limpiar" la memoria cuando la reserva para una variable. Puede haber quedado valores "basura" en la memoria de pila, de anteriores llamadas a otras funciones, y "meternos" valores "inesperados" o erróneos en nuestra variable sin inicializar.

Lo mejor es no dejar cosas al azar. Así que recomiendo inicializar, al menos con un valor conocido, al definir.

¿"Al menos con un valor conocido"? Sí, no necesariamente se ha de inicializar con el valor que realmente queremos, sino que le ponemos un valor "provisional" para posteriormente asignarle el valor que realmente nos interesa. De lo que se trata es que si nos "olvidamos" de poner el valor "bueno" al menos tiene un valor "conocido".

Por ello recomiendo:

int Var1 = 0, Var2 = 0, Var3 = 0;

Por ejemplo, las variables MilisPrevias, en lugar de declararlas e inicializarlas con el valor de millis(), las podemos declarar e inicializar a cero, para posteriormente "inicializarlas" con millis() en el setup().

// Declaramos las variables e inicializamos con un valor "conocido"
unsigned long MillisPrevias1 = 0, MillisPrevias2 = 0, MillisPrevias3 = 0, MillisPrevias4 = 0, MillisPrevias5 = 0;

setup() {
    // Inicialización "práctica" de las variables con el valor de millis();
    MillisPrevias1 = MillisPrevias2 = MillisPrevias3 = MillisPrevias4 = MillisPrevias5 = millis();
}

Sí, se pueden "concatenar" un igual tras de otro. Esto hace que la función millis() se llame una sola vez y el valor devuelto se le asigne a las cinco variables. A todas el mismo valor.

Por eso mismo, porque la operación de asignación = suele devolver el valor asignado y los if() se cumplen cuando el valor de la expresión a evaluar es distinto a cero, es por lo que la condición...

    if(x = 3) {

... se cumple siempre.

Mientras que la condición...

    if(x = 0) {

... no se cumple nunca.

El usar un =, simple igual, en lugar de un ==, doble igual, a la hora de comparar, es un fallo típico que causa que el programa no se comporte como deseamos.

Veamos si sabrían decir qué muestra en el monitor serie este programa:

int x = 3;
void setup () {
    Serial.begin(9600);
    Serial.println(x);
    Serial.println(x = 4);
    Serial.println(x == 4);
    Serial.println(x);
}

void loop() {
}
6

Súper clarísimo, como siempre.

IgnoranteAbsoluto:
Lo mejor es no dejar cosas al azar. Así que recomiendo inicializar, al menos con un valor conocido, al definir.

De acuerdo, tengo más de una variable mal declarada de esa manera.

IgnoranteAbsoluto:
Por ejemplo, las variables MilisPrevias, en lugar de declararlas e inicializarlas con el valor de millis(), las podemos declarar e inicializar a cero, para posteriormente "inicializarlas" con millis() en el setup().

Pero no es lo mismo asignarles el valor antes de setup()?
Si entre que se inicializa una variable y entra en el setup() pasa una fracción de segundo, para qué "duplicar" el proceso de inicializar y luego en el setup() asignarles otro valor?

IgnoranteAbsoluto:
El usar un =, simple igual, en lugar de un ==, doble igual, a la hora de comparar, es un fallo típico que causa que el programa no se comporte como deseamos.

Me recuerda uno de los primeros programas que hice que ponía dentro del if un solo igual, y siempre se cumplía la condición, me volvía loco, es muy frustrante, lo posteé aquí y me lo hizo notar un compañero, no recuerdo quién.

IgnoranteAbsoluto:

int x = 3;

void setup () {
   Serial.begin(9600);
   Serial.println(x);
   Serial.println(x = 4);
   Serial.println(x == 4);
   Serial.println(x);
}

void loop() {
}

Pues lo tengo claro hasta el doble igual, la variable tiene al declararse un valor de 3 y luego se le asigna un valor de 4, pero lo de "x==4" (dá 1) no lo entiendo.

7

albertoG1:
¿Pero no es lo mismo asignarles el valor antes de setup()?
Si entre que se inicializa una variable y entra en el setup() pasa una fracción de segundo, ¿para qué "duplicar" el proceso de inicializar y luego en el setup() asignarles otro valor?

Lo ponía a modo de ejemplo. Pero aún así, nunca se sabe si te puede llegar a interesar asignar a varias variables un mismo valor a todas.

Eso de (x == 4) lo puse para que se "viera" la diferencia con (x = 4) y también para que se "viera" el booleano que nos devuelve una expresión lógica.

Se supone que un valor booleano sólo puede ser verdadero o falso; true o false; uno o cero... Pues eso ha de ser el valor de la expresión (x == 4), uno o cero.

Digamos que, cuando el C/C++ espera un valor booleano, el valor cero lo interpreta como falso, y cualquier valor distinto de cero lo interpreta como verdadero. Así que true o false se pueden sustituir por un 1 o un 0 (cosa que no recomiendo).

Ejemplo para "ver" el valor de los booleanos:

void setup () {
    boolean cero = 0;
    boolean tres = 3;
    boolean negativo = -3;
    Serial.begin(9600);
    Serial.print(F("true = ")); Serial.println(true);
    Serial.print(F("false = ")); Serial.println(false);
    Serial.print(F("HIGH = ")); Serial.println(HIGH);
    Serial.print(F("LOW = ")); Serial.println(LOW);
    Serial.print(F("3 < 4 = ")); Serial.println(3 < 4);
    Serial.print(F("3 > 4 = ")); Serial.println(3 > 4);
    Serial.print(F("cero = ")); Serial.println(cero);
    Serial.print(F("tres = ")); Serial.println(tres);
    Serial.print(F("negativo = ")); Serial.println(negativo);
}

void loop() {
}