La línea de código " resultado = resultado + arreglo[a] " no posee Operador + Sobrecargado,
cierto ? pues entiendo que no se está sumando un Elemento ( resultado ) del Array al mismo
Array ( arreglo[a] ) : Entonces, esto es lo que no entiendo ...... quizá si lo interpreto como
" i = i + 1 " sea coherente ?? ; o entender que " si en resultado no hay ningún Valor, súmese a este un Valor del Array " (?)
include <iostream>
using namespace std;
int a = 0; // Contador a 0
int resultado;
int cantidad; // Cantidad de Elementos del ARRAY
int main( )
{
cout << "\n\tIngrese la Cantidad de N\243meros que desea Sumar :";
cin >> cantidad;
int arreglo[ cantidad ]; // Nombre del ARRAY
// Se declara pues será utilizado en el WHILE
// reemplazando " a " POR " cantidad "
while ( a < cantidad ) // Mientras el Nro de veces que se va a repetir ( " a " )
// la cantidad de Nros ingresados SEA MENOR a la
// " cantidad " de Elementos del ARRAY
// ( ya q no queremos que se tenga en cuenta el " \0 " )
{
cout << "\n\tIngrese un N\243mero :";
cin >> arreglo[a];
a ++;
}
a = 0; // Se resetea el Contador pues será utilizado nuevamente
while ( a < cantidad )
{
resultado = resultado + arreglo [a];
a ++;
}
cout << "\n\tEL RESULTADO DE LA SUMA DE TODOS LOS NUMEROS INGRESADOS ES :" << "" << resultado << endl;
return 0 ;
}
Gracias x leer el Mensaje.
No hay ninguna operador sobrecargado, es una elemental suma de enteros entre una variable global y un elemento de un array cuyo resultado se asigna a la variable global.
Es exactamente igual a esto:
resultado += arreglo[a];Cita de: Eternal Idol en 18 Noviembre 2021, 09:27 AM1) mayor es una variable global y su valor inicial es 0 por defecto. ¿Que crees que deberia ser? Es eso o un valor indefinido ya que no inicializaste la variable ... por suerte no hace falta al ser una variable global.
Me cito, cambia mayor por resultado.
No entiendo muy bien lo que estás preguntando pero básicamente para entender esa línea tienes que tener claras las siguientes premisas:
- resultado es de tipo int
- arreglo es de tipo int[] por lo que arreglo[a] es de tipo int
- int + int = int
- El operador = tiene menos preferencia que el operador + por lo que primero se realiza la suma y después la asignación
Y ahora entrando más concretamente en tu código:
- Como resultado es una variable global y no se ha inicializado, vale 0 (como explica Eternal Idol) -> Con variables locales esto no se cumple -> Es obligatorio inicializarlas (y las globales por claridad también se recomienda inicializarlas explícitamente)
- Ahora te pongo unos valores de ejemplo para 'arreglo' y vemos lo que está pasando:
resultado = 0
arreglo = {1, 2, 3, 4}
Iteracion 0 -> resultado = resultado + arreglo[0] -> resultado = 0 + 1 -> resultado = 1
Iteracion 1 -> resultado = resultado + arreglo[1] -> resultado = 1 + 2 -> resultado = 3
Iteracion 2 -> resultado = resultado + arreglo[2] -> resultado = 3 + 3 -> resultado = 6
Iteracion 3 -> resultado = resultado + arreglo[3] -> resultado = 6 + 4 -> resultado = 10
Gracias x tu paciencia: Evidentemenete olvidé lo que me explicó Eternal Idol hace unas
semanas: que como " resultado " es una variable global, no hace falta inicializarla y por defecto
vale " 0 "
Ahora bien; reescribí el Código con todas Variables Locales, e inicializadas ( con excepción de " arreglo " pues espera que el usuario le ingrese Valores) : e igualmente funciona bien ......
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 ?
Gracias y Saludos !
Cita de: Eternal Idol en 15 Diciembre 2021, 09:46 AM
No hay ninguna operador sobrecargado, es una elemental suma de enteros entre una variable global y un elemento de un array cuyo resultado se asigna a la variable global.
Es exactamente igual a esto:
resultado += arreglo[a];
Me cito, cambia mayor por resultado.
Gracias : se me pasó que me lo habías recordado.
Claro que funciona si inicializas a 0 manualmente una variable local, no hay ninguna razon para esperar un comportamiento diferente.
Necesitas leer algun libro de C++ urgentemente, entender la diferencia entre variables locales y globales es algo muy elemental.
Cita de: snoopty en 16 Diciembre 2021, 05:54 AM
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.
- 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.
#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]
#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.
Gracias totales !
Excelente explicación.
Sólo te presento aquí algunas Notas para que leas sobre ( y que me digas si no estoy en lo
correcto en los casos en que fuere ) tu Segundo Código, luego de la antepenúltima Línea :
// 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 = = = = Debo anular la Línea, entiendo que es coherente hacerlo.
// cout << "Constante global: " << constanteGlobal << endl; // Muestra: "Constante global: 0" = = = No muestra nada : Sólo arroja ERROR al compilar ( ? )
// CIERRE DE PROGRAMA :
// A C L A R A C I Ó N
// Cerrando así, con " func(); ", CODE devuelve = " variableGlobal = 10 " pues tiene en cuenta tanto los Cuerpos ' int main( ) ' como ' void func( ) '
// " variableGlobal = 10 "
// P E R O
// Si cerrara con " return 0; " , CODE devuelve = " variableGlobal = 10 " pues tiene en cuenta sólo el Cuerpo ' int main( ) '
func(); // X supuesto q para cerrar con " getch (); " se comportará como con " return 0; " pero habrá que ' dar Cabecera de #include <conio.h> '
}
Una más...
int arreglo[ cantidad ];
error C2131: expression did not evaluate to a constant arm64 msvc v19.latest
cantidad no es constante, lo que hace que esta no sea una expresión válida C++.
Es válida en C99, pero no lo es no lo fue nunca en C++.
Se trata de VLA "Variable Length Array" (array de longitud variable). Algunos compiladores lo implementan como una extensión al lenguaje pero otros no, por ejemplo del del Visual Studio...
A mí esa línea de código no me arroja error .... quizás te referís a declaración de errores inexactas de algún IDE; Qué IDE usas ? En Codeblocks 20.03 no tuve problemas .... y mirá que es bastante " sensible "
Cita de: snoopty en 18 Diciembre 2021, 02:51 AM
A mí esa línea de código no me arroja error .... quizás te referís a declaración de errores inexactas de algún IDE; Qué IDE usas ? En Codeblocks 20.03 no tuve problemas .... y mirá que es bastante " sensible "
Como ya te explicaron
no es C++ standard, igual que conio.h, tenes suerte de que no te de error al compilar.
Cita de: snoopty en 17 Diciembre 2021, 05:39 AM
Gracias totales !
Excelente explicación.
Sólo te presento aquí algunas Notas para que leas sobre ( y que me digas si no estoy en lo
correcto en los casos en que fuere ) tu Segundo Código, luego de la antepenúltima Línea :
// 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 = = = = Debo anular la Línea, entiendo que es coherente hacerlo.
// cout << "Constante global: " << constanteGlobal << endl; // Muestra: "Constante global: 0" = = = No muestra nada : Sólo arroja ERROR al compilar ( ? )
// CIERRE DE PROGRAMA :
// A C L A R A C I Ó N
// Cerrando así, con " func(); ", CODE devuelve = " variableGlobal = 10 " pues tiene en cuenta tanto los Cuerpos ' int main( ) ' como ' void func( ) '
// " variableGlobal = 10 "
// P E R O
// Si cerrara con " return 0; " , CODE devuelve = " variableGlobal = 10 " pues tiene en cuenta sólo el Cuerpo ' int main( ) '
func(); // X supuesto q para cerrar con " getch (); " se comportará como con " return 0; " pero habrá que ' dar Cabecera de #include <conio.h> '
}
No, no es cierto eso que has agregado en el "Cierre del programa"...
En C/C++ las funciones devuelven únicamente lo que se especifique en el 'return'. No es como otros lenguajes que devuelven la última instrucción de la función.
La función main() es un caso especial: Es la única función que si no se especifica el return, el propio compilador agrega un 'return 0' automáticamente. Digamos que lo correcto sería especificar el return siempre al final del main() pero te encontrarás muchos casos en los que no se pone porque está implícito y solemos ahorrarnos (me incluyo) esa línea por comodidad sobre todo en programas simples.
PD: No utilices la función getch() de la librería <conio.h>. Como ya se ha mencionado por ahí: esta librería no es estándar y por lo tanto puede haber compiladores que fallen si la incluyes. En su lugar tienes la función getchar() que puedes usar con el mismo propósito pero con la ventaja de que esta pertenece a <stdio.h>.