Mantén la atención porque en este tutorial vas a hallar la solución que buscas.Esta reseña ha sido analizado por nuestros expertos para garantizar la calidad y veracidad de nuestro contenido.
Solución:
Adyacente string los literales están concatenados, por lo que puede hacer esto:
cout << " _______________________ _______ _ _______ _______ _______ _______ _ _______ n"
"( ____ __ __/ ___ ) ____ / ( ___ ) /| ____ ____ )( ____ ( ___ ) /|n"
"| ( / ) ( | ( ) | ( / / / | ( ) | ) ( | ( / ( )|| ( / ( | ( ) | ) ( |n"
"| (_____ | | | (___) | | | (_/ / | | | | | | | (__ | (____)|| (__ | | | | | | | _ | |n"
"(_____ ) | | | ___ | | | _ ( | | | | ( ) ) __) | __)| __) | | | | | | |( )| |n"
" ) | | | | ( ) | | | ( | | | | _/ /| ( | ( ( | ( | | | | | | || || |n"
"/____) | | | | ) ( | (____/ / | (___) | / | (____/ ) __| ) | (____/ (___) | () () |n"
"_______) )_( |/ |_______/_/ / (_______) _/ (_______// __/|/ (_______/_______)_______)n";
O, más exactamente, quizás:
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"
Con más sensatez, use endl. Esto es sutilmente diferente de solo " n" después de cada línea, porque también eliminará el flujo de salida.
prueba 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 anterior también te permitirá usar caracteres como la barra invertida sin necesitar dos de ellos, muestra todo y no reconoce códigos de control, como n, etc. Muy útil.
Esto se llama "string literal "y se agregó en C ++ 11. Puede encontrar más información sobre los comandos aquí, consulte específicamente el prefix "R" que es para raw_characters: https://en.cppreference.com/w/cpp/language/string_literal
Otros ya han sugerido usar endl. Si bien esto no es (necesariamente) algo malo, usar endl vacía el búfer de la secuencia junto con la escritura de una nueva línea. Al contrario de lo que implica una de las respuestas que ha obtenido, utilizando endl lo hace no ayuda (en absoluto) con la traducción de la nueva línea a cualquier secuencia de caracteres que la plataforma utiliza normalmente para señalar el final de una línea. Utilizando newline está garantizado para ser exactamente equivalente a stream << "n" << flush;". La traducción de nuevas líneas a " r", o " n" o " r n", o lo que prefiera la plataforma, se realiza en un nivel diferente y newline no tiene nada que ver con eso.
los flush que lo haga, sin embargo, puede (y con frecuencia lo hará) ralentizar su E / S, a veces por un margen bastante considerable. Siempre que solo escriba unas pocas líneas (por ejemplo, un par de cientos de caracteres) probablemente sea completamente irrelevante. Sin embargo, si está escribiendo un archivo grande, use endl en lugar de "n" puede resultar fácilmente en una desaceleración de 10 veces (de hecho, iría tan lejos como para decir que gran parte de la idea de que los iostreams son lentos se deriva directamente del uso endl).
Eso no quiere decir que nunca haya ninguna razón para usar endl. los flush asegura que todo lo que se ha escrito en la secuencia se elimina inmediatamente del búfer de la biblioteca estándar y se envía al sistema operativo. Si desea asegurar una visualización inmediata, endl puede ser útil. Del mismo modo, si está registrando y es fundamental que su registro siempre refleje el estado conocido más reciente de un programa, endl puede ser (extremadamente) útil para asegurar que lo que ha escrito realmente se registre, no se pierda en un búfer cuando / si la aplicación falla.
Entonces, endl tiene sentido a veces, pero probablemente el 95% del tiempo que se usa, es realmente inapropiado (por ejemplo, es poco probable que logre algo útil en cualquiera de las respuestas a esta pregunta).
Reseñas y puntuaciones
Agradecemos que desees añadir valor a nuestro contenido informacional aportando tu experiencia en las explicaciones.