Скажем, Вы хотите распечатать одно из тех замечательных изображений ASCII-творчества. Как можно сделать это без cout
каждая строка индивидуально?
Смежные строковые литералы объединены, поэтому вы можете сделать это:
cout << " _______________________ _______ _ _______ _______ _______ _______ _ _______ \n"
"( ____ \__ __/ ___ ) ____ \ \ /\ ( ___ )\ /| ____ \ ____ )( ____ \ \ ( ___ )\ /|\n"
"| ( \/ ) ( | ( ) | ( \/ \ / / | ( ) | ) ( | ( \/ ( )|| ( \/ ( | ( ) | ) ( |\n"
"| (_____ | | | (___) | | | (_/ / | | | | | | | (__ | (____)|| (__ | | | | | | | _ | |\n"
"(_____ ) | | | ___ | | | _ ( | | | | ( ) ) __) | __)| __) | | | | | | |( )| |\n"
" ) | | | | ( ) | | | ( \ \ | | | |\ \_/ /| ( | (\ ( | ( | | | | | | || || |\n"
"/\____) | | | | ) ( | (____/\ / \ \ | (___) | \ / | (____/\ ) \ \__| ) | (____/\ (___) | () () |\n"
"\_______) )_( |/ \|_______/_/ \/ (_______) \_/ (_______// \__/|/ (_______/_______)_______)\n";
или, точнее, возможно, возможно:
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"
более разумно, используют ENDL
. Это тонко отличается от просто «\ n» после каждой строки, потому что вы также промокаете выходной поток.
Это довольно просто К счастью. Просто используйте EndL, когда вы хотите начать другую строку.
cout << stuff << endl
<< morestuff << endl
<< evenmorestuff << endl;
Я хотел бы указать, что я предпочитаю использовать EndL, потому что он должен работать, даже если вы находитесь на платформе, которая требует «\ R \ n» вместо просто «\ N».
Другие уже предложили использовать endl
. Хотя это и не (обязательно) плохо, но использование endl
прошивает буфер потока вместе с записью новой строки. В отличие от подтекста в одном из полученных ответов, использование endl
помогает не (вообще) переводить новую строку в любую символьную последовательность, которую платформа обычно использует для сигнализации конца строки. Использование newline
гарантированно будет точно эквивалентно потоку << "\n" << flush;"
. Перевод новых строк на "\r", или "\n", или "\r\n", или как там предпочитает платформа, осуществляется на другом уровне и newline
тут ни при чем. Однако
flush
, что он делает, может (и часто будет) замедлять ввод/вывод, иногда на довольно значительный запас. До тех пор, пока вы пишете только несколько строк (например, пару сотен символов), это, вероятно, совершенно не относится к делу. Однако, если Вы пишете большой файл, то использование endl
вместо "\n"
может легко привести к 10-кратному замедлению (на самом деле, я бы зашел так далеко, что большая часть идеи о том, что iostreams являются медленными, проистекает непосредственно из использования endl
).
Это не значит, что никогда нет причин использовать endl. Флеш flush
уверяет, что все, что было записано в поток, сразу же вымывается из буфера стандартной библиотеки и отправляется в операционную систему. Если вы хотите гарантировать немедленное отображение, то endl
может быть полезен. Точно так же, если вы занимаетесь протоколированием, и очень важно, чтобы ваш лог всегда отражал последнее известное состояние программы, endl
может быть (очень) полезным, чтобы гарантировать, что то, что вы написали, действительно попадает в лог, а не теряется в буфере, когда/если приложение выходит из строя.
Итак, endl
временами имеет смысл, но, вероятно, в 95% случаев его использование действительно неуместно (например, он вряд ли выполнит что-либо полезное в любом из ответов на этот вопрос).