In C ++, wie ASCII-Art auf die Konsole drucken?
https://stackoverflow.com/questions/2181375
-
24-09-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianFrage
Angenommen, Sie wollen eine jener großen ASCII-Art-Bilder zu drucken. Wie können Sie, dass jede Zeile einzeln ohne cout tun?
Lösung
sind Angrenzend Stringliterale verkettet, so können Sie dies tun:
cout << " _______________________ _______ _ _______ _______ _______ _______ _ _______ \n"
"( ____ \__ __/ ___ ) ____ \ \ /\ ( ___ )\ /| ____ \ ____ )( ____ \ \ ( ___ )\ /|\n"
"| ( \/ ) ( | ( ) | ( \/ \ / / | ( ) | ) ( | ( \/ ( )|| ( \/ ( | ( ) | ) ( |\n"
"| (_____ | | | (___) | | | (_/ / | | | | | | | (__ | (____)|| (__ | | | | | | | _ | |\n"
"(_____ ) | | | ___ | | | _ ( | | | | ( ) ) __) | __)| __) | | | | | | |( )| |\n"
" ) | | | | ( ) | | | ( \ \ | | | |\ \_/ /| ( | (\ ( | ( | | | | | | || || |\n"
"/\____) | | | | ) ( | (____/\ / \ \ | (___) | \ / | (____/\ ) \ \__| ) | (____/\ (___) | () () |\n"
"\_______) )_( |/ \|_______/_/ \/ (_______) \_/ (_______// \__/|/ (_______/_______)_______)\n";
oder, genauer gesagt, vielleicht:
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"
Weitere sinnvoll, den Einsatz endl. Dies ist auf subtile Weise anders als nur „\ n“ nach jeder Zeile, da Sie auch den Ausgabestrom spülen werden.
Andere Tipps
versuchen so etwas wie:
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.)";
... der obige Code erlaubt es Ihnen auch Charaktere wie den umgekehrten Schrägstrich zu verwenden \ ohne zwei von ihnen zu benötigen, zeigt es alles und erkennt keine Steuercodes, wie \ n usw. Sehr praktisch.
Edit: Dies wird als „roh Stringliteral“ und wurde in C ++ 11 hinzugefügt. Sie können weitere Informationen zu den Befehlen finden Sie hier: https://en.cppreference.com/ w / cav / language / string_literal
Andere haben bereits mit endl vorgeschlagen. Dies ist zwar nicht (unbedingt) eine schlechte Sache, endl mit leert den Puffer des Stroms zusammen mit einer neuen Linie zu schreiben. Im Gegensatz zu der Implikation in einen der Antworten, die Sie bekommen haben, verwendet mit endl tut nicht Hilfe (überhaupt) mit der neuen Linie, was auch immer Zeichenfolge übersetzt die Plattform normalerweise das Ende eines zu signalisieren Linie. Mit newline garantiert genau entspricht stream << "\n" << flush;" sein. Übersetzen von neuen Linien „\ r“ oder „\ n“ oder „\ r \ n“, oder was auch immer die Plattform zieht, auf einer anderen Ebene erfolgt und newline hat nichts damit zu tun.
Die flush, dass es funktioniert, aber kann (und oft) verlangsamt Ihr I / O, die manchmal durch einen ganz erheblichen Spielraum. Solange Sie nur ein paar Zeilen (zum Beispiel ein paar hundert Zeichen) zu schreiben, es ist wahrscheinlich völlig irrelevant. Wenn Sie eine große Datei schreiben, jedoch mit endl statt "\n" leicht in einem 10-fach Verlangsamung (in der Tat führen kann, würde ich so weit gehen, dass viel von der Idee zu sagen, dass iostreams langsam ergibt sich unmittelbar aus der Verwendung endl ).
Das ist nicht zu sagen, dass es nie ein Grund zur Verwendung Endl. Die flush stellt sicher, dass, was auch immer in den Stream geschrieben wurde, wird sofort der Standard-Bibliothek-Puffer gespült und an das OS gesendet. Wenn Sie sofortige Anzeige gewährleisten möchten, können endl nützlich sein. Ebenso, wenn Sie die Protokollierung tun, und es ist wichtig, dass Ihre Log immer den neuesten bekannten Zustand eines Programms widerspiegeln, kann endl (extrem) nützlich sein, um sicherzustellen, dass das, was du hast wirklich geschrieben angemeldet wird, nicht in einem Puffer verloren wenn / falls die Anwendung abstürzt.
So macht endl Sinn manchmal, aber wahrscheinlich 95% der Zeit, dass es verwendet wird, ist es wirklich unpassend (zum Beispiel, es ist unwahrscheinlich, etwas Sinnvolles in eine der Antworten auf diese Frage zu erreichen).
Es ist ziemlich dankbar einfach. Verwenden Sie einfach Endl, wenn Sie eine andere Linie beginnen soll.
cout << stuff << endl
<< morestuff << endl
<< evenmorestuff << endl;
möchte ich feststellen, dass ich mit endl viel lieber, weil es funktionieren soll, auch wenn Sie auf einer Plattform, die erfordert „\ r \ n“ statt nur „\ n“.
