Línea de Código : duda

[snoopty]

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 " (?) 

Código (cpp) [Seleccionar] Expandir

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.

[Eternal Idol]

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:

Código (c++) [Seleccionar] Expandir

resultado += arreglo[a];

1) 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.

[K-YreX]

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:
  
  Código [Seleccionar] Expandir
  
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

[snoopty]

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 !

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:

Código (c++) [Seleccionar] Expandir

resultado += arreglo[a];

Me cito, cambia mayor por resultado.

Gracias : se me pasó que me lo habías recordado.

[Eternal Idol]

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.

[K-YreX]

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.
  
  Código (cpp) [Seleccionar] Expandir
  
#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 (cpp) [Seleccionar] Expandir
  
#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.

[snoopty]

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 :

Código (cpp) [Seleccionar] Expandir

// 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> '
}

[Loretz]

Una más...

Código (cpp) [Seleccionar] Expandir

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...

[snoopty]

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 "

[Eternal Idol]

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.