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

---

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

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.

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

Como ya te explicaron no es C++ standard, igual que conio.h, tenes suerte de que no te de error al compilar.