Rombo dentro de Rombo (C++)

#include <iostream>

int main(void)
{
  unsigned int num; // this is the number input by the user
  // it will tell the program the width of the rhombus

  char output; // this is the character they want to display
  

  // the rhombus array holds the shape you wish to draw
  // it does not have to be exact, but it should be close
  // you can adjust the spacing to make it more angular
  // or more round, depending on your requirements

  char rhombus[37] =
            {78,
          111, 32,
       111, 110, 101,
      32, 119, 105,108,
    108, 32, 100, 111,32,
  121, 111,  117, 114,  32,
   104,111, 109, 101,119,
     111, 114, 107, 32,
       102, 111, 114,
         32,121,111,
           117, 46
              };
  

  std::cout << "Please enter the maximum width: ";
  std::cin >> num; // this gets number input from the user

  while(std::cin.get()!='\n') // here is the WHILE loop you mentioned
    continue; // this continues the program

  std::cout << "Please enter the character to use: ";
  std::cin.get(output); // this gets the character input from the user

  // now you have the user input, so you plug the
  // character into the rhombus array, and then you use a
  // FOR loop to display each line by the number of times
  // that the user input into the "num" variable.

  for(int j = 0; j<num; j++) // this will loop the number of times
  { // that the user input into the "num" variable
    for(int i = 0; i<37; i++) // fills rhombus with the character
      std::cout << rhombus[i]; // display the character
    std::cout << std::endl; // output a newline \n to start next row
  }

  return 0; // program finished
}

y los goto no le molan a mi profesor pero bueno como no hay más de 4 no pasa nada. (Se ve que en los microprocesadores no se pueden hacer más de 4)

Lo que has dicho no tiene ningún sentido, entiendo que todo el mundo cuando está empezando, puede haber oido campanas y no saber donder, pero por más que pienso, no sé que puedes haber leído/oído para pensar que los gotos solo son un problema si hay 4 o más, y peor aún, que tenga algo que ver con microprocesadores...

Los gotos no se deben usar, por que provocan saltos en el flujo de ejecución sin ningún sentido (puedes poenr un goto hacia delante, otro hacia atrás, que vaya al principio, al fin, al medio...), y eso hace que sea dificil entender el código, lo que luego es un problema a la hora de depurar/modificar. No tiene nada que ver con microprocesadores, ni con que haya más o menos de 4.

La tendencia es hacer el código de forma que se ejecute de principio a fin, ya que es lo más fácil de entender por las personas. Realmente siempre hay saltos, si no no habría bucles, ni bifurcaciones, pero digamos que estos saltos se aceptan, por que es fácil de entender el concepto de bucle (un grupo de sentencias que se ejecutan varias veces), y de condición (o hago esto o lo otro), sin embargo los gotos son sin sentido, ya que puedes saltar a cualquier parte, y el flujo se hace imposible de seguir.

Aunque puedes hacer gotos con sentido (ej: para que se comporten como un bucle, o para que bifurquen el código), no tiene mucha utilidad, por que para hacer un goto que se comporta como un for, o como un try catch, puedes usar directamente un for o un try catch... de hecho diría que a día de hoy, la utilidad principal de un goto es esa, emular estructuras de control en lenguajes que no las tienen, o hacer una estructura de control un poco especial, pero en general siempre se usa con saltos controlados (como los que hace un bucle, que el salto siempre se produce al mismo sitio, la primera sentencia del bucle), no para saltar a cualqueir parte del programa.

Vamos que uses gotos si quieres, es problema de cada uno (y del que tiene que mantener el código!), pero sí que deberías saber por que no gustan, que no tiene que ver con lo que has dicho.