Entonces, pues, si me podrías explicar si haber definido a " ' resultado ' como Local y no Global " - aunque funcione bien el Código - sería un error conceptual ..... o en todo caso:
..... ¿ En qué caso/s específico/s es obligatorio definir a una variable como Global ?
Realmente el error es el opuesto: definir la variable 'resultado' global cuando en este caso debería ser local...... ¿ En qué caso/s específico/s es obligatorio definir a una variable como Global ?
- Una variable local sólo es accesible desde dentro del ámbito (scope) en que se define.
- Una variable global es accesible desde cualquier lugar del código.
Código
#include <iostream> using namespace std; // Como dije antes, aunque las variables globales se inicializan a 0 por defecto, es mejor especificarlo para facilitar su lectura // Normalmente una variable sin inicializar se entiende que se le va a dar un valor concreto mas adelante y que no importa el valor que tenga en este momento int variableGlobal = 0; const int CONSTANTE_GLOBAL = 0; void func() { int variableLocalFunc = 0; cout << "Variable global: " << variableGlobal << endl; // Como se llama en el main() despues de modificar el valor de variableGlobal -> Mostrara 10 cout << "Variable local main: " << variableLocalMain << endl; // ERROR: La variable local de main() no es accesible desde aqui } int main() { // Una variable local no se inicializa a 0 por defecto. Por lo tanto es necesario inicializarla explicitamente (dado el caso) // Al igual que antes, se puede dejar sin inicializar si se le va a dar un valor mas adelante (estando seguros de que no se va a usar esta variable antes de darle un valor) // Lo de inicializar siempre todas las variables al momento de declararlas ya depende de gustos int variableLocalMain = 0; variableGlobal = 10; cout << "Variable global: " << variableGlobal << endl; // Muestra: "Variable global: 10" constanteGlobal = 10; // ERROR: Es una constante -> No se puede modificar cout << "Constante global: " << constanteGlobal << endl; // Muestra: "Constante global: 0" func(); }
La norma general es:
- No definir variables globales prácticamente nunca (si estás empezando quédate con que nunca debes definir una variable global). Las variables globales son accesibles desde cualquier parte del programa. Imagina un programa con 200 archivos diferentes y con variables globales, ¿cuántas posibilidades hay de que alguna variable tenga el mismo nombre? ¿Qué pasa si estás usando una variable global en un fichero pero está siendo modificada desde otro fichero? Problemas.
- Las constantes globales sí están permitidas. En programas muy grandes hay que tener cuidado con declarar cosas globales pero en programas pequeños puedes declarar las constantes que necesites globales por tenerlas todas al principio del fichero y tener así el cuerpo de las funciones más reducido.
- Si las variables locales sólo son accesibles desde la función en que se crean, ¿cómo puedo acceder a una variable definida en una función desde otra? Te presento: los parámetros (gran invento). Las utilidades de los parámetros es que permite digamos "enviar" variables de una función a otra. Además por defecto estas variables se pasan por valor (se envía una copia) y no por referencia (se envía la original) por lo que si se modifican dentro de la función que las recibe, no afectará a la función que las envió.
- Si las variables pasadas como parámetro no se ven afectadas fuera de la función, ¿cómo puedo hacer cambios en una variable y que estos se mantengan fuera? Te presento: el valor de retorno (otro gran invento) [o el paso por referencia, pero este es más avanzado, no deberías usarlo si no es estrictamente necesario y si estás empezando no creo que lo sea]
Código
#include <iostream> using namespace std; // Funcion que modifica el parametro pero este no se ve modificado fuera void incrementVoid(int num) { num++; cout << "Incremento void: " << num << endl; } // Funcion que modifica el parametro y lo devuelve para que sea asignado fuera y asi mantener su nuevo valor int incrementReturn(int num) { num++; cout << "Incremento return: " << num << endl; return num; } // Funcion que modifica el parametro pasado por referencia -> Modifica el actual entonces no hace falta devolverlo void incrementReference(int &num) { num++; cout << "Incremento referencia: " << num << endl; } int main() { int num = 1; incrementVoid(num); // Mostrara: "Incremento void: 2" cout << "Valor num en main: " << num << endl; // Mostrara: "Valor num en main: 1" (no se ha visto modificado) num = incrementReturn(num); // Mostrara: "Incremento return: 2" cout << "Valor num en main: " << num << endl; // Mostrara: "Valor num en main: 2" (en la linea anterior le hemos asignado el valor devuelto por incrementReturn()) incrementReference(num); // Mostrara: "Incremento referencia: 3" (En la linea anterior num ya valia 2 y la funcion le ha vuelto a incrementar 1) cout << "Variable num en main: " << num << endl; // Mostrara: "Valor num en main: 3" (la funcion incrementReference() ha modificado la variable num original por lo que el cambio se mantiene) }
Como ya he dicho, y repito, no debes usar parámetros por referencia de momento. Seguro que lo que estés pensando puedes hacerlo igual con un return.