Mensajes

Cierto, cierto.
No me di cuenta en ese momento porque estaba contestando todavía con una legaña en el ojo 

Otro pequeño detalle a tener en cuenta es que un programa ejecutado "sin argumentos", realmente se está ejecutando con un argumento: el nombre del programa. Es decir, si se ejecuta un programa sin argumentos, argc vale 1.
Si no se quiere contar este argumento, se podría hacer algo así:

Código (c) [Seleccionar] Expandir


#define NUM_HIJOS (argc - 1) // IMPORTANTE: Usar parentesis

Aunque personalmente preferiría usar argc directamente en vez del define.
Por lo demás, tema zanjado.

Si intentas definir esa constante antes del main() tendrás problemas pues argc no existe en ese punto.

EDIT: Tenía mis dudas y tras probarlo, no da problemas (al menos en mi caso). Funciona correctamente.

Puedes usar directamente los parámetros de la función main():

• argc -> Contiene el número de argumentos. Si no se pasa nada: argc = 1
  
• argv -> Contiene los argumentos. Si no se pasa nada: argv[0] = <nombre_programa>
  
  Prueba este código (con diferentes argumentos) para entenderlo mejor:
  
  Código (c) [Seleccionar] Expandir
  
#include <stdio.h>

int main(int argc, char *argv[]) {
 printf("Numero de argumentos: %d\n\n", argc);

 for(int i = 0; i < argc; ++i) {
   printf("Argumento %d: %s\n", i, argv[i]);
 }
}

Al tener todos los arrays declarados por separado, tienes que hacer la suma de cada uno de ellos por separado (no puedes hacerlo todo en un bucle). La mejor forma para ello sería una función así:

Código (cpp) [Seleccionar] Expandir


int sumArray(int numbers[], int size) {
  int sum = 0;
  // Aqui haces la suma desde 0 hasta size-1
  return sum;
}

Y de esta manera tan solo tendrías que hacer:

Código (cpp) [Seleccionar] Expandir


const int NUM_ARRAYS = 4;
const int ARRAY_SIZE = 5;

int main() {
  int a[ARRAY_SIZE] = {...};
  int b[ARRAY_SIZE] = {...};
  //...

  int r[NUM_ARRAYS];
  r[0] = sumArray(a, ARRAY_SIZE);
  r[1] = sumArray(b, ARRAY_SIZE);
  //...
}

Otra posibilidad para poder hacerlo mediante un bucle sin importar la cantidad de arrays sería con una matriz (matriz = array de arrays)

Código (cpp) [Seleccionar] Expandir


const int NUM_ARRAYS = 4;
const int ARRAY_SIZE = 5;

int main() {
  int arrays[NUM_ARRAYS][ARRAY_SIZE] = {
    {a0, a1, a2, a3, a4},
    {b0, b1, b2, b3, b4},
    {c0, c1, c2, c3, c4},
    {d0, d1, d2, d3, d4}
  };

  int sums[NUM_ARRAYS] = {0}; // Asi inicializas la primera posicion a 0 y el resto al valor por defecto (que es 0 tambien)

  for(int i = 0; i < NUM_ARRAYS; ++i) {
    sums[i] = sumArray(arrays[i], ARRAY_SIZE);
  }
}

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

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

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.

[Eternal Idol]

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

La idea principal es simple: genera un número aleatorio en el rango [0, JComboBox.getItemCount() - 1] usando la clase Random.

Ahora depende de lo que quieras exactamente (siendo x el número aleatorio generado):

• Si lo que quieres es obtener el elemento x del comboBox: Utiliza el método JComboBox.getItemAt()
  
• Si lo que quieres es dejar seleccionado el elemento x en el comboBox: Utiliza el método JComboBox.setSelectedIndex()

La matriz no se muestra correctamente porque eso no es automático, tienes que hacerlo tú.

En el último for() estás mostrando todos los valores en una línea seguido de un espacio entre cada elemento.
Si quieres que se muestre como una matriz, tienes que agregar un salto de línea después de mostrar cada fila.

Sobre la otra pregunta. Imagina las matrices:

Código [Seleccionar] Expandir


A = | 1  2 |          B = | 5  6 |
    | 3  4 |              | 7  8 |

Si hacemos C = A * B, el resultado es:

Código [Seleccionar] Expandir


C = | (1 * 5 + 2 * 7)    (1 * 6 + 2 * 8) |
    | (3 * 5 + 4 * 7)    (3 * 6 + 4 * 8) |

Cada vez que avanzamos una columna de la matriz A (1 -> 2 | 3 -> 4) también avanzamos una fila de la matriz B (5 -> 7 | 6 -> 8)
Al avanzar ambas a la vez, sólo se utiliza un for(). Como ca == fb, da igual hacer el for() usando ca o fb como condición. Si te fijas la K se utiliza tanto en A como en B pero en A hace variar las columnas y en B hace variar las filas.

Si se usase otro for() dentro para B, entonces estarías haciendo combinatoria (todos con todos) porque no avanzarías filas (de B) y columnas (de A) a la vez:

Código [Seleccionar] Expandir


(1 * 5 + 1 * 7 + 2 * 5 + 2 * 7)    (1 * 6 + 1 * 8 + 2 * 6 + 2 * 8)
(3 * 5 + 3 * 7 + 4 * 5 + 4 * 7)    (3 * 6 + 3 * 8 + 4 * 6 + 4 * 8)

Tengo estos codigos pero me falta que se cambie el monto que se tiene por alguna manera no me deja colocar 23,250 que es lo que se desea
tambien me falta como tal el historial y el pago de servicio :,(

No veo el problema en colocar la cantidad inicial:

Código (cpp) [Seleccionar] Expandir

float saldoActual = 23250; // con float tienes suficiente. No necesitas usar double, pero funcionaria igual

Te falta hacer el menú en sí. Para ello lo mejor es utilizar un switch:
(Y guardar el resultado en un int. No necesitas usar un string para esto)

Código (cpp) [Seleccionar] Expandir


int opcion;
cout << "***** MENU DE EJEMPLO *****" << endl
     << "\t1. Opcion 1 del menu de prueba" << endl
     << "\t2. Opcion 2 del menu de prueba" << endl
     << "\t..." << endl
     << "Opcion: ";
cin >> opcion;

switch(opcion) {
    case 1:
        // hacer lo que sea
        break;

    case 2:
        // hacer lo que sea
        break;

    default:
        // la opcion elegida no es una de las controladas antes
        break; // este break es opcional
}

La parte del historial tampoco tiene nada del otro mundo. Sin embargo, creo que no está bien pues hay una opción de "Historial" y otra de "Saldo" y al elegir la opción de "Historial" lo que quieres mostrar es el saldo. Yo diría que la opción "Saldo" muestra el saldo actual y la opción "Historial" muestra todos los movimientos (ingresos y pagos) que se han hecho.
De todas formas, limitándome al enunciado:
Si se elige la opción "Historial" haces un 'cout' y muestras el saldoActual.
Si se elige la opción "Pago" haces prácticamente lo mismo que para retirar dinero pero pidiendo otro mensaje como concepto del pago.

He probado a ejecutar tu código y tus mismos ejemplos en Windows (tanto desde CMD como Powershell) y... Funciona correctamente.

De todas formas, yo diría que el problema puede andar por las líneas 29 y 30. Utiliza:

Código (c) [Seleccionar] Expandir


estado_nodo = (char*)malloc(num_nodos * sizeof(char));
camino = (int*)malloc(num_nodos * sizeof(int));

Si eso no soluciona tu problema, muestra mensajes por pantalla entre las líneas de los cálculos para ver hasta qué línea se ejecuta exactamente.

Además de esto, otra cosa aparte: Cuando definas una macro compleja con #define, usa siempre paréntesis.

Código (c) [Seleccionar] Expandir


#define A 2 * 2
#define B (2 * 2)

int a = 16 / A; // a = 16 / 2 * 2 = 16
int b = 16 / B; // b = 16 / (2 * 2) = 4