for(int i = 0; i < 0; ++i); // Este bucle no se va a ejecutar nunca. Iteraciones = 0
for(int i = 0; i < 1; ++i); // Este bucle se va a ejecutar 1 vez: i = {0}. Iteraciones = 1
for(int i = 0; i < num; ++i); // Este bucle se va a ejecutar num-veces si num >= 0 y 0-veces si num < 0. Iteraciones = MAX(0, num)
 
// Y si i no empieza en 0, todo funciona igual
for(int i = 10; i < 15; ++i); // Este bucle se va a ejecutar 5 veces: i = {10, 11, 12, 13, 14}. Iteraciones = 5
 
// De forma general:
for(int i = a; i < b1; ++i); // Este bucle se va a repetir (b1-a) veces o 0 si el resultado es negativo (como antes). Iteraciones = MAX(0, (b1-a)) 
// Y teniendo en cuenta que el anterior bucle es igual a:
for(int i = a; i <= b1-1; ++i); // Iteraciones: MAX(0, (b1-a)) = MAX(0, (b1-1-a+1))
 
// Consideramos que b2 = b1-1 y juntamos conclusiones:
for(int i = a; i <= b2; ++i); // Iteraciones: MAX(0, (b2-a+1)) 

for ( int i = 1; i <= numero; i++ ) {
  factorial = factorial * i;
} 

for(int i = 2; i <= numero; ++i) {
  factorial *= i; // Forma corta de escribir: factorial = factorial * i
} 

• Parametriza los números sueltos que tienes por el programa:

const int NUM_FILAS = 5;
const int NUM_COLS = 5;
 
int main() {
  int matriz[NUM_FILAS][NUM_COLS];
  //...
} 

• Utiliza funciones auxiliares (y a ser posible optimizadas):

int isPrime(int num) {
  // Asumimos que el numero es primo si es mayor que 1 (el 1 no se considera primo)
  int prime = (num > 1);
  // Dividir entre 1 o entre el propio num sabemos que va a dar resto 0 siempre. No hace falta hacerlo (empezamos en 2 y llegamos hasta num-1)
  // Seguimos comprobando mientras siga siendo primo. En cuanto encontremos un divisor paramos
  for(int i = 2; i < num && prime; i++) {
    prime = (num % i != 0);
  }
  return prime;
} 

• En las últimas líneas, si tienes 2 líneas que estás repitiendo en todos los if(), ponlas una sola vez después del if(). Evita repetir código.
• Además si primero comprueba si a>b y después si b>a; si ninguna se cumpla ya sabes que a==b. El último if() sobra también.

• Te piden parar cuando el codigo introducido sea -1. Sin embargo, tú estás mezclando código (double) y nombre (double[] pero que debería ser string).
• Tienes una variable 'par' que no usas. Además la comprobación de la línea 34 es incorrecta. Un número no es par cuando el cociente de dividirlo entre 2 sea 0, sino el resto.
• Las variables codigo y stock... no pintan muy bien como double (aunque podría ser pero me parece muy raro que sea el caso). No creo que tengas 1.55555 productos con código 10.12345, no??

// Un 'Producto' se compone de los siguientes atributos
struct Producto {
  string nombre;
  int codigo;
  float precio;
  int stockActual;
  int stockMinimo
};
 
// Te dicen que como mucho puede haber 100 productos:
const int MAX_PRODUCTOS = 100;
 
// Y ahora ya empezamos el programa en si
int main() {
  Producto productos[MAX_PRODUCTOS]; // Array de productos para guardar cada uno de ellos
  int numProductos = 0; // Variable para saber cuantos productos tenemos guardados
 
  // Ahora hay que pedir un codigo. Si es -1 no hacer nada y en caso contrario seguir pidiendo datos:
  int codigo;
  do {
    cout << "Introduce un codigo: ";
    cin >> codigo;
 
    if(codigo != -1) {
      productos[numProductos].codigo = codigo;
      // Aqui deberas seguir pidiendo datos y guardandolos en el elemento correspondiente del array
      //...
      // Al final tendras que aumentar el contador
      ++numProductos;
    }
  } while(codigo != -1 && numProductos < MAX_PRODUCTOS); // Cuando alguna de las condiciones sea falsa, se dejaran de pedir productos
 
  // Y ahora ya puedes recorrer el array de productos y hacer los calculos que te pidan:
  for(int i = 0; i < numProductos; ++i) {
    //...
  }
  //...
} 

cin.getline(char_array);
getline(cin, string_var); 

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

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

#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]);
  }
} 

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

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);
  //...
} 

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);
  }
}