Digamos que usted quiere imprimir uno de los grandes de arte ASCII imágenes. ¿Cómo se puede hacer eso sin cout cada línea por separado?

Debido a que C++11 puede utilizar el raw literal de cadena. en.cppreference.com/w/cpp/language/string_literal stackoverflow.com/a/34737663/1749675 para ver un ejemplo.

OriginalEl autor Mark | 2010-02-02

4 Comentarios

  1. 16

    Adyacentes literales de cadena están concatenados, por lo que puede hacerlo:

    cout << " _______________________ _______ _          _______         _______ _______  _______ _       _______         \n"
            "(  ____ \__   __/ ___  )  ____ \ \    /\  (  ___  )\     /|  ____ \  ____ )(  ____ \ \     (  ___  )\     /|\n"
            "| (    \/ ) (  | (   ) | (    \/ \  // | (   ) | )   ( | (    \/(    )|| (    \/(     | (   ) | )   ( |\n"
            "| (_____   | |  | (___) | |     |  (_//  | |   | | |   | | (__   | (____)|| (__   | |     | |   | | | _ | |\n"
            "(_____  )  | |  |  ___  | |     |   _ (    | |   | | (   ) )  __)  |     __)|  __)  | |     | |   | | |( )| |\n"
            "      ) |  | |  | (   ) | |     |  ( \ \   | |   | |\ \_//| (     | (\ (   | (     | |     | |   | | || || |\n"
            "/\____) |  | |  | )   ( | (____/\  / \ \  | (___) | \   /| (____/\ ) \ \__| )     | (____/\ (___) | () () |\n"
            "\_______)  )_(  |/    \|_______/_/   \/ (_______)  \_/ (_______//  \__/|/     (_______/_______)_______)\n";

    O, más exactamente, tal vez:

    cout << "                              .::/-                                                                                                                                                             \n"
            "                              .+++/                                                                                                                                                            \n"
            "                   `.::`       /+++.                                                                                                                                                            \n"
            "                  -////.      :+++-                                                                                                                                                             \n"
            "                    .////-`    .+++/`                                                                                                                                                           \n"
            "                    `:///:`   `/++/.                                                                                                                                                            \n"
            "            ..`        -////.   -+++:                                                                                                                                                           \n"
            "           :+++:-`      .////:` ./++/`                                                                                                                                                          \n"
            "          `-/+++++/-.    `:////.`:++/.                                                                                                                                                          \n"
            "             `.:/++++/:.`  -////..:--`                                                                                                                                                          \n"
            "                 .-/+++++/-..::.`                                                                                                                                                               \n"
            "       `:::-..``    `.:/++++-                                                                                                                                                                   \n"
            "       -++++++///:--.```.-/-                                                                                                                                                                    \n"
            "        `.--:///++++++//::.                                                                                                                                                                     \n"
            "`--.          ``..-::///+/``---                                                 -+-                                                             ./oso- /++:                                     \n"
            "-oo+  -::::----....````... `ooo                  :s-                            /mo                                                            -dmmhy:`hmmo                                     \n"
            "-oo+  /+++++++++++++++++/. `ooo                  om:                            /mo             ````     ```      ```    ``.``      ```  `.``  ommd`` `hmmo       ``.``    ```     ```     ```  \n"
            "-oo+  ...----::::////+++/` `ooo      `/ssyss+:`.ohmyoo` .+ssyss+-     -+syys+-  /mo    -o+.  .ohdmmdho- -hdd/  `sdds` :shmmmdy/`  .hddshdmmhoydmmmhy:`hmmo    .+hdmmmds- .ddd/  .ddh-   +ddh. \n"
            "-oo+  ```````````````````  `ooo     .yh-.``-/-  .sm/.` `/o-```-sd+  .sd+-..-++` /mo  .odo.  :dmmy+/smmm: +mmh-  /mmd- +mmh+:/smmy- .dmmdo/+s:`/ymmm++.`hmmo   .dmmh++smmd+`ommd` `ymmmy  .hmm+  \n"
            "-oo+  +oooooooooooooooooo- `ooo     -dy.         om:           -dy` +m/        /mo`+dy-   `smmy`  `smmy``smms`.hmm/-dmd+---:hmmo`.dmm+       ommd   `hmmo   ommh.   ommh..ymm+ +mmdmm/ommy.  \n"
            "-oo+  /++++++++++++++++++. `ooo      -oyhyyys/`  om:   `:osyyyyymy``sm-         /myhyhd:   `smms    +mmh` `dmm/smms  :dmmddddddddo`.dmm/      ommd   `hmmo   smmy`   /mmd. :dmd+dmy-ymd+hmd:   \n"
            "-oo+                       `ooo          ``.+do  om:   /do.    -dy``om:         /md/``od+` `ommh.  `ymmy`  :dmmmmy.  .hmd/`````.`  .dmm/      ommd    hmmo   +mmh-   smmy` `smmmmm- :dmmmmo    \n"
            "-oo+:::::::::::::::::::::::/ooo     -+:.```.od+  +mo.` /do.```.omy` .sd/.``.//` /mo    +dy. -ymmdysdmmh-    +mmmh-    :dmmyoosdd+` .dmm/      ommd    ommmso.`ymmdyshmmh:   .hmmm+   +mmmd`    \n"
            "-oooooooooooooooooooooooooooooo     ./syyyyyo:`  `:sys.`:syyyys+yo`  `:syyyyo:` :h/    :ys` `:shddhs/`     `ohy/     ./shddhy+-  .shh:       /hhy    `:syhs. `:oyhdhs/.     /hho`   `shh/    \n"

    Más sensatez, uso endl. Este es sutilmente diferente a simplemente «\n» después de cada línea, porque también te lave el flujo de salida.

    Se trata de la «Épica» de la fuente, de patorjk.com’s del generador.
    Estos ejemplos no funcionan como se llena de secuencias de escape. En todas partes se ve un «\» es el comienzo de una secuencia de escape y no se mostrará en la consola. Compilar y obtener advertencias acerca de ellos en realidad. Estoy tratando de averiguar cómo este fue escogido como la mejor respuesta todavía.
    Los ejemplos que se dan warning: unknown escape sequence: '\_' jugando con las fuentes no añade nada útil para la respuesta.

    OriginalEl autor John Feminella

  2. 5

    intente algo como:


    cout << R"(place multiple lines
    of text here
    and it will display exactly
    as you have it between the two brackets,
    line feeds and all.)";

    …el código de arriba también permitir el uso de caracteres como la barra invertida \ sin necesidad de dos de ellos, muestra de todo y no reconoce los códigos de control, como \n etc. Muy práctico.

    OriginalEl autor Neil Roy

  3. 2

    Otros ya han sugerido el uso de endl. Si bien esto no es necesariamente una mala cosa, el uso de endl vacía la secuencia de amortiguamiento junto con la escritura de una nueva línea. Contrario a la implicación en una de las respuestas que he recibido, utilizando endl hace no ayuda (a todos) con la traducción de la nueva línea a cualquier secuencia de caracteres de la plataforma utiliza normalmente para indicar el final de una línea. El uso de newline está garantizado a ser equivalente a stream << "\n" << flush;". La traducción de las nuevas líneas «\r», o «\n» o «\r\n», o lo que sea la plataforma prefiere, se realiza en un nivel diferente y newline no tiene nada que ver con ella.

    La flush que lo hace, sin embargo, puede (y a menudo lo hará) retrasan la I/O, a veces, por un margen bastante considerable. Mientras usted está sólo a escribir un par de líneas (por ejemplo, un par de cientos de caracteres) probablemente sea completamente irrelevante. Si estás escribiendo un archivo de gran tamaño, sin embargo, el uso de endl en lugar de "\n" puede resultar en una 10x desaceleración (de hecho, iría tan lejos como para decir que gran parte de la idea de que los iostreams son lentos se deriva directamente de uso de endl).

    Eso no quiere decir que no hay ninguna razón para usar endl. El flush asegura que todo lo que se ha escrito de la secuencia está vacía inmediatamente fuera de la biblioteca estándar de amortiguamiento, y se envía al sistema operativo. Si desea asegurarse de visualización inmediata, endl puede ser útil. Del mismo modo, si usted está haciendo el registro, y es importante que el registro siempre reflejar la información más reciente estado de un programa, endl puede ser extremadamente útil para asegurar que lo que he escrito realmente se registra, no se pierde en un búfer cuando/si la aplicación se bloquea.

    Así, endl tiene sentido a veces, pero probablemente el 95% del tiempo que se utiliza, es muy inapropiado (por ejemplo, es poco probable lograr algo útil en cualquiera de las respuestas a esta pregunta).

    OriginalEl autor Jerry Coffin

  4. 0

    Es bastante sencillo gracias a dios. Sólo uso endl cuando desea iniciar otra línea.

    cout << stuff << endl
         << morestuff << endl
         << evenmorestuff << endl;

    Me gustaría decir que me gusta mucho más el uso endl porque debería funcionar incluso si usted está en una plataforma que exige «\r\n» en lugar de «\n».

    Mientras que una respuesta obvia, la impresión de que muchas de las líneas de este modo puede convertirse en una carga para la CPU si se hace con frecuencia. Cada vez que se use el operador sobrecargado << está ocultando una llamada a una función, por la impresión de texto multilínea requiere de MUCHAS llamadas a la función.
    Sí que puede convertirse en una carga para hacer de esa manera, pero si todo lo que está haciendo es la impresión de un poco de arte ascii, no debería ser un problema. La otra forma sería hacer el trabajo de embalaje a todos en una gran cadena y empujando todo a la vez. He tenido que hacerlo en alguna ocasión pero la mayoría del tiempo, este método no es un problema.
    Tu comentario acerca de std::endl es tonto. Incluso si usted está en una plataforma que requiere \r\n en lugar de \n como su nativo terminador de línea, \n es todavía la nueva línea de terminator en C y C++, y el I/O bibliotecas convertirá para usted. (Esta es la diferencia entre el modo de texto y binarios en modo arroyos.) std::endl es un poco menos eficiente que la cruda \n ya que innecesariamente los vaciados de la secuencia.
    Usted está probablemente en lo cierto, pero tenía problemas con él hace muchos, muchos años. Junto a nada de ser utilizado en estos días tiene problemas con el solo uso de ‘\n’.
    Leer de nuevo la cuestión. Él preguntó específicamente cómo hacerlo sin couting cada línea.

    OriginalEl autor Player1st

Dejar respuesta

Please enter your comment!
Please enter your name here