Пишем первую программу. Мнимая немощь С++. Функции. Библиотеки функций. Пространства имен. Пример простой функции сложения. Вывод текста на экран. Параметры программы.
Настало время написать первую программу на С++. Она будет очень простая и мы, постепенно усложняя, станем развивать ее от серии к серии. Сегодня вы узнаете много нового.
Парадокс - язык С++ очень мощный, но сам по себе он ничего не умеет. Представьте себе умелого мастера, который приходит к вам что-то чинить, но у него нет ни шуроповёрта, ни шурупов. Или - гениальный мозг, способный безошибочно и быстро считать, однако не знающий ни одной формулы.
В 80-е годы был очень популярен язык программирования BASIC. Его учили в школах, институтах, это был своего рода народный язык программирования, очень простой и к тому же встроенный в доступные домашние компьютеры вроде ZX Spectrum и Atari. В восьмидесятые BASIC достиг своего расцвета, хотя появился в 1964. До того, как люди придумали хранить файлы на аудиокассетах и дискетах, интерпретатор BASIC’а распространялся на свернутых в катушки бумажных лентах, в частности для компьютера Альтаир 8800. Стоимость такой бумажной катушки составляла 200 долларов. Кстати, именно этот вариант BASIC стал одним из истоков империи Билла Гейтса, ибо над тем BASIC’ом трудились тогда еще программисты Билл Гейтс и Пол Аллен.
Я сказал “интерпретатор BASIC”. Интерпретатор (на английском его называют “translator”), как и компилятор, получает исходный код программы на языке высокого уровня, но не переводит его в машинный код, а выполняет сам. Иными словами, компилятор переводит нам исходник в автономный исполняемый файл, а интерпретатор этого не делает, будучи просто средством для трактовки и выполнения исходного кода программы. Вы не можете без интерпретатора запустить такую программу.
Программы на интерпретируемых языках работают медленнее тех, что компилятор переводит в машинный код, именно из-за этой прослойки между исходником и системой - прослойки-интерпретатора. Современный популярный такой язык - конечно же Java, где интерпретатор из маркетинговых соображений гордо именуется Джава-машиной.
Что же, BASIC был своеобразной Java восьмидесятых годов. В программе на Бейсике, если вы хотели вывести что-нибудь на экран, можно было написать нечто вроде
PRINT "HELLO"
И когда точка выполнения программы доходила до этого места, то на экран выводилось заключенное в кавычки слово “HELLO”. В язык BASIC был встроен оператор PRINT, который выводил указанный после него в кавычках текст на экран.
В не менее популярном языке программирования Pascal той же цели служит слово writeln, сокращение от write line, написать строку:
WriteLn ("Hello!");
А в С++ нет встроенной возможности вывести на экран простейший текст.
Как же так? Ведь на С++ пишутся операционные системы, крутейшие игры, текстовые и звуковые редакторы - да всё. Как это возможно, если С++ сам ничего не умеет?
Один из путей познания - обратиться в библиотеку. Есть библиотеки с книгами. Чего-то не знаем - пошли в библиотеку, почитали нужную книжку.
В прошлой серии я кратко упомянул функции - поименованные алгоритмы, подпрограммы. Функция это как кулинарный рецепт. В рецепте пирожка может быть написано - взять столько-то муки, добавить столько-то воды, перемешать. По сути рецепт это настоящая программа.
Вооружившись кулинарной книгой, вы можете приготовить любое блюдо, описанное в ней, при условии, если у вас есть нужные продукты и вы будете точно следовать алгоритму - рецепту.
Для С++ существуют так называемые библиотеки функций. Эдакие кулинарные книги с функциями-алгоритмами. Например, библиотека OpenGL предоставляет функции трехмерной графики. Или, под Windows есть библиотека DirectX с функциями двумерной и трехмерной графики, а также работы со звуком и многим другим. Таким образом за счет библиотек функций язык С++ обретает дополнительные возможности.
Технически, простейшая библиотека состоит из двух файлов. Первый это файл с самими алгоритмами, в откомпилированном или исходном коде, то есть в последнем случае текстовый файл. А второй файл называется заголовком. В нем просто перечислены названия функций и их параметры. Параметры это переменные, которые вы передаете внутрь функции.
Давайте на русском языке, но приблизив его к С++, напишем функцию Пирожок.
Пирожок (float мука, float сахар, float вода)
{
Взять муку;
Добавить в муку сахар;
Добавить воду;
Перемешать;
Вылепить пирожки;
Выложить на сковородку;
Жарить;
}
Первая строка, там где название Пирожок - это заголовок функции. Далее в круглых скобках идут параметры - мука, сахар и вода, имеющие тип данных float, потому что всё это дробные числа.
То, что в фигурных скобках - строки с точкой и запятой в конце - это выражения. Из них состоит тело функции. Выражения будут выполняться одно за другим. Текущее выполняемое выражение называется в программировании точкой выполнения.
В теле функции мы используем полученные в скобках параметры. Мы можем передать в функцию, при помощи этих параметров, сколько взять муки, воды и сахара.
И вот кто-то, какой-то программист, написал библиотеку функций, библиотеку под названием Вкусняшки, где есть рецепты: Пирожок, Тортик и Пирожное. Вы раздобыли эту библиотеку и хотите использовать оттуда функцию Пирожок. Что для этого нужно сделать? Скопировать текст функции, алгоритм, в свою программу?
Нет, всё гораздо проще.
Нам понадобятся всего две строчки.
Первая это подключение к нашей программе библиотеки, чтобы программа знала, откуда брать функцию Пирожок. Для этого в начале программы мы пишем:
#include "Вкусняшки"
include с решеткой в начале указывает, что упомянутый далее заголовочный файл библиотеки должен быть помещен, вставлен в нашу программу. Если имя файла заключить в кавычки, это значит, что файл находится в той же директории, что наша программа. А если заключить имя файла между знаками меньше и больше, вот так:
#include <Вкусняшки>
Это будет означать, что мы используем общесистемную библиотеку, которая находится в положенном ей операционной системой месте и ее используют еще и другие программы, что позволяет экономить место.
После такого подключения заголовочного файла библиотеки, нам в программе станут доступны рецепты из этой библиотеки, но лишь те, которые перечислены в заголовочном ее файле. Иными словами, там могут быть и другие функции, другие рецепты, но они как бы вспомогательные, служебные, и задействованы только внутри библиотеки, а вне ее - не доступны.
Все функции, доступ к которым открыт, перечисляются в виде заголовков функций в заголовочном файле. Это простой текстовый файл, где написаны заголовки, например:
Пирожок (float мука, float сахар, float вода);
Торт (float мука, float сахар, float вода, float крем, float цукаты);
и так далее.
И вот мы хотим в нашей программе испечь пирожок. Для этого нужно вызывать функцию - то есть написать ее имя и передать ей в скобках параметры - сколько чего в пирожок кладем:
Пирожок (1, 0.2, 0.5);
Вот мы перечисляем параметры в круглых скобках. Первый параметр у нас мука - 1 - килограмм. Второй - сахар, берем 0.2, двести граммов. Третий - вода, 0.5 поллитра.
И нас не заботит, что именно записано в рецепте. Всё, что нам нужно знать - это как называется функция и формат ее параметров.
Но что, если другой программист или повар тоже написал кулинарную библиотеку, назвал ее Обжора, и мы хотим использовать рецепты-функции не только из библиотеки Вкусняшки, но также из библиотеки Обжоры? Нет проблем, включаем ее в нашу программу:
#include "Вкусняшки"
#include "Обжора"
Теперь нам доступны функции из Вкусняшек и Обжоры.
Однако, в Обжоре тоже есть функция под названием Пирожок. Она готовит другой пирожок, по другому рецепту, но название у нее такое же. Пирожок! Как быть? Какую функцию вызовет наша программа, когда мы обратимся к функции Пирожок? К функции из библиотеки Вкусняшки или из Обжоры?
Тут мы приходим к важному понятию языка С++ - пространству имен. С++ предусматривает, что в разных библиотеках могут быть функции с одинаковыми именами. Чтобы различать их, вводится понятие о пространстве имен. Это как один Иванов живет на улице Вишневой, а другой Иванов на улице Каштановой. Улицы в нашем случае - разные пространства имен. Мы не будем их путать, если в разговоре прибавим, такой-то Иванов - с Вишневой, а другой - с Каштановой.
Пространство имен объявляется внутри библиотеки. Для Вкусняшек будет написано:
namespace Вкусняшки
{
Пирожок (float мука, float сахар, float вода);
Торт (float мука, float сахар, float вода, float крем, float цукаты);
и так далее;
}
Итак, мы пишем ключевое слово языка С++, namespace, указываем имя пространства, и далее в фигурных скобках перечисляем заголовки функций, которые будут принадлежать этому пространству имен, то есть - пространству имен Вкусняшки.
Для библиотеки Обжора в ней будет написано нечто подобное:
namespace Обжора
{
Пирожок (float мука, float сахар, float вода);
Лимонад (float лимоны, float сахар, float вода);
и так далее;
}
В С++ есть оператор доступа, две пары двоеточий, вот такой - ::
В нашей программе, если мы захотим вызвать функцию Пирожок из библиотеки Вкусняшки, мы, используя этот оператор, напишем:
Вкусняшки::Пирожок (1, 0.6, 0.5);
Таким образом мы указываем, из какого пространства имен мы вызываем функцию пирожок. Хотим из Обжоры? Пишем:
Обжора::Пирожок (1, 0.6, 0.5);
Но у этого дела есть обратная сторона медали - громоздкость. Когда функция объявлена в пространстве имен, мы вынуждены постоянно предварять обращение к ней именем пространства и оператором доступа, парой двоеточий.
Если мы уверены, что между используемыми нами библиотеками нет совпадений в именах функций, то можем разрешить использование всех функций из пространств имен без указания этих имен. Для этого достаточно написать в программе:
using namespace Имя такого-то пространства;
Например, мы не используем библиотеку Обжора, а используем Вкусняшки, но во “Вкусняшках” функции всё равно объявлены в пространстве имен. Чтобы каждый раз не писать
Вкусняшки::Пирожок (1, 0.6, 0.5);
Мы предваряем вызов этой функции выражением, записанным где-нибудь после подключения заголовочного файла Пирожок:
using namespace Пирожок;
И далее уже пишем просто:
Пирожок (1, 0.6, 0.5);
Это всё были весьма отвлеченные и неработающие примеры на условном, хотя и подобном С++, языке.
Итак, библиотеки функций. Библиотеки предоставляют, кроме функций, много чего еще - например классы и объекты. Что это такое, вы узнаете позже.
Для С++ существует стандартная библиотека. Она так и называется - стандартная библиотека, и состоит из нескольких меньших, я бы сказал - тематических библиотек. Библиотека математических функций. Библиотека для работы с текстом. Библиотека для ввода с клавиатуры и вывода на экран - да, именно в ту самую консоль, про которую я так много уже рассказывал. Видите, неспроста!
Теперь еще немного теории, которая уже близка к практике. Напишем уже настоящую, рабочую функцию на С++ - весьма скучную, но очень простую, чтобы на ее примере уже разобраться с функциями более обстоятельно. Покамест мы просто пишем функцию, а учиться ею пользоваться - вызывать ее - будем позже.
Наша супернудная функция будет называться sum и ее назначение - складывать переданные ей в параметрах два числа и выдавать результат. Да, помимо получения параметров, функции могут выдавать буквально наружу, из себя, некое число, а иногда не просто число, но про это позже.
Мы напишем функцию sum в нескольких вариантах, от худшего к лучшему, от громоздкого к лаконичному. Где напишем? Пока теоретически, без привязки к телу программы.
Итак, вариант первый, при виде коего каждый программист содрогнется:
int sum (int a, int b)
{
int result;
result = a + b;
return result;
}
В первой строке у нас идет заголовок функции. Мы видим ее название sum, за которым, в круглых скобках следуют два параметра, a и b, имеющие тип int, то бишь это целые числа. Точка с запятой после круглых скобок в заголовке функции ставятся только в заголовочном файле, где нет тел функций, а есть только заголовки. Точка с запятой после заголовка функции не ставится, если следом за заголовком мы пишем тело функции - это называется определением функции. Когда у нас и заголовок, и тело вместе.
Разбираем дальше.
Перед именем функции, в ее заголовке, у нас тоже стоит тип int. Что это значит? Это значит, что функция вернет наружу себя значение указанного типа, в нашем случае int. Что значит вернет? Это значит, что мы сможем присвоить ее значение некой переменной.
Например, мы захотим сложить два числа, скажем, 3+2, при помощи этой функции и записать результат вычисления в переменную x. Тогда мы напишем в программе:
int x = sum (3, 2);
И функция sum вернет нам (отдаст число) результат своей работы, а оператор равенства присвоит этот результат переменной x.
Такое обращение к функции называется вызовом функции.
Но вернемся к нашей функции sum:
int sum (int a, int b)
{
int result;
result = a + b;
return result;
}
Итак, перед именем функции мы указываем тип возвращаемого ею значения. Если функция просто что-то делает - например играет музыку - и ничего не возвращает, то указываем тип под названием void, что означает “пустота”.
После заголовка идет, уже в фигурных скобах, тело функции - набор выражений, обычно записанных построчно, где каждое выражение завершается точкой с запятой.
Выделение пробелами произвольное, как кому нравится, кроме того, фигурные скобки могут быть не отдельно на каждой строке, а допустим первая фигурная скобка рядом с последней круглой, а последняя фигурная рядом с последней точкой с запятой. Дело вкуса.
После тела функции точка с запятой не ставится. Точка с запятой ставится после ВЫЗОВА функции, обращения к функции, если на этом выражение заканчивается, иначе говоря если вызов функции не является частью более сложного выражения.
Поясню последнее на примере:
int x = sum (3, 2);
тут мы ставим точку с запятой после вызова функции, потому что на вызове функции sum выражение завершается.
Другой пример:
int x = sum (3, 2) + 2;
Тут мы не ставим точку с запятой после вызова функции, поскольку к полученному из функции результату мы еще добавляем двойку. И уже тогда завершаем выражение точкой с запятой.
Но разберем тело функции. Тело заключено в фигурные скобки, которые следуют после заголовка функции.
int sum (int a, int b)
{
int result;
result = a + b;
return result;
}
В первой строчке тела функции мы объявляем, то есть создаем, новую переменную типа int, под именем result, в которую мы позже запишем результат сложения двух переданных функции параметров:
int result;
Когда мы объявляем такую переменную, она не имеет определенного значения, и в ней будет какое-нибудь случайное число. Чтобы сразу задать значение переменной, можно написать так:
int result = 7;
В этом примере мы сразу присваиваем переменной result значение 7, число 7. Математические знаки вроде =, +, -, /, * называются операторами. Продолжаем разбирать нашу уродливую функцию sum.
int sum (int a, int b)
{
int result;
result = a + b;
return result;
}
Во второй строке тела функции мы присваиваем переменной result итог сложения переменных-параметров a и b. То есть мы складываем то, что передали в параметрах в качестве a и b, первого параметра и второго, и полученную сумму оператором = присваиваем переменной result.
Наконец, в третьей строке тела функции мы при помощи ключевого слова return, то есть в переводе возврат, возвращаем из функции, выдаем наружу ее, значение переменной result, то число, которое содержится в этой переменной. Как только точка выполнения в функции доходит до слова return, происходит выход из функции с возвратом значения, указанного после слова return.
Можно ли сократить нашу функцию? Да, во-первых, вот так:
int sum (int a, int b)
{
int result = a + b;
return result;
}
Здесь мы сразу после объявления переменной result присваиваем ей итог вычисления a + b. И во второй строке возвращаем из функции значение этой переменной.
Давайте сократим эту функцию еще. Вот так:
int sum (int a, int b)
{
return a + b;
}
Здесь мы вообще отказались от промежуточной переменной result, и сразу словом return возвращаем сумму a + b.
В использовании функций есть еще много тонкостей, которых мы коснемся в будущем. Но покамест перейдем наконец от теории к практике, хотя ненадолго!
Напишем простейшую программу на С++ и попробуем ее откомпилировать, превратить в исполняемый файл.
Вот текст, исходный код программы. Вместо слова “привет” можете написать что угодно. Важно! В С++ ИМЕЕТ значение, какими буквами вы пишете. То есть, Return **это не **return, это две разные вещи. Компилятор С++ знает ключевое слово return, маленькими буквами, но не знает с большой. То же относится ко всему остальному. Итак, ключевые слова пишутся только маленькими буками. Имена функций и переменных могут быть произвольными, но если переменная объявлена маленькими буквами, так ее и следует использовать дальше, это касается функций и всего остального.
#include <iostream>
using namespace std;
int main (int argc, char *argv[])
{
cout << "Привет!" << endl;
return 0;
}
Этот текст программы вы можете скопировать в текстовый редактор или проще скачать отсюда.
Если набираете текст вручную, сохраните файл под именем, например, 04-01.cpp, хотя как хотите, я просто формализую для примера. 04 это номер текущего урока, а 01 - первый в нем работающий пример. cpp - традиционное расширение файла для программ на С++.
Также, если вы хотите, чтобы вывелся текст на русском языке, а не крякозяблами, сохраните его в кодировке UTF-8 - современный вындовый Блокнот делает это по умолчанию.
Но где сохранить файл, набираете вы его вручную или скачали? Пользователи Windows! Сохраните не где-то в случайном месте, а в папке *c:/cygwin/home/имя пользователя *, потому что именно эта папка будет текущей, когда вы запускаете Терминал Cygwin попадаете в консоль.
Пользователи Linux! Сохраните этот файл где угодно, лишь бы вы могли добраться туда через консоль используя команду cd - change dir. То же может быть применимо кстати и пользователями Windows, главное чтобы вам было удобно добираться таким образом в консоли до папки, где сохраняете примеры программ.
Запускаем теперь консоль. Итак, в консоли вы должны попасть в директорию, куда сохранили файл 04-01.cpp. Если вы используете Windows и запустили Терминал Cygwin, и сохранили файл в папку c:/cygwin/home/имя пользователя, то вы сейчас именно в этой папке.
Теперь нам нужно запустить компилятор GCC и передать ему в качестве параметра имя файла с программой. Даем команду:
g++ 04-01.cpp
Нажимаем Энтер. Если текст программы введен правильно, компилятор переведет ее с языка С++ в машинные коды. В Линуксе вы получите исполняемый файл под именем a.out, а в Windows - a.exe. Это имя исполняемого файла по умолчанию.
В Линуксе его можно запустить, набрав ./a.out и нажав Энтер, в Windows - ./a.exe и нажать Энтер.
Конечно, имя исполняемого файла можно выбрать. Для этого компилируем программу с ключом -o (английская o, от “output”, вывод, выходной файл), например так:
g++ 04.cpp -o myprogram
То есть после -o пишем имя файла, в который будет записан откомпилированный код. В нашем примере получится исполняемый файл под именем myprogram.
Запустите полученную программу. Она должна вывести на терминал слово “Привет!”. Значит, всё сделано правильно и программа работает как надо.
Разберем теперь текст, исходный код нашей программы!
#include <iostream>
using namespace std;
int main (int argc, char *argv[])
{
cout << "Привет!" << endl;
return 0;
}
В первой строке мы подключаем к нашей программе библиотеку iostream из состава стандартных библиотек С++. Библиотека iostream дает нам доступ к консольному вводу и выводу. IO - популярное сокращение от input/output, ввод-вывод. Хотите получать набранный текст и выводить текст на экран? Подключите к программе библиотеку iostream.
Во второй строке мы видим уже знакомое выражение using namespace - использовать пространство имен. Все средства из стандартной библиотеки относятся к пространству имен std, это сокращение от “стандарт”. Вот мы и указываем на использование этого пространства имен, чтобы не писать его каждый раз перед именем функции:
using namespace std;
А далее мы видим нечто знакомое…
int main (int argc, char *argv[])
{
cout << "Привет!" << endl;
return 0;
}
Это же настоящая функция! Она называется main. В переводе - основная.
Да, вы верно подумали. Программа это тоже функция, только непростая. Разница в том, что обычные функции могут иметь какие угодно имена, а основная функция программы имеет жестко заданное имя main. Когда система запускает программу, то запускает функцию main.
В каждой программе на С++ должна быть функция main. В ней вы пишите свои алгоритмы, в ней вы вызываете другие функции. Это тело программы.
Поглядим на заголовок функции main:
int main (int argc, char *argv[])
Ага, функция main возвращает значение типа int. Что может возвращать целая программа? Код ошибки. Она возвращает код ошибки - есть определенные номера ошибок, либо 0, если ошибки нет и программа завершилась нормально, без ошибок. То есть, когда вы в программе напишите return 0, произойдет мгновенный выход из программы. Например, можно сделать так, что по нажатию на клавишу Escape будет вызываться return 0.
int main (int argc, char *argv[])
Теперь о параметрах функции main. Они на первый взгляд заковыристы. Но вспомним, как бывает, что вы щелкаете мышью по текстовому файлу, и он открывается в редакторе. Или - выбираете несколько файлов, а потом в контекстном меню выбираете “Открыть в Фотошопе”, и они открываются в нем.
Как же Фотошоп знает, что вы хотите открыть в нем эти файлы?
Очень просто. Система передает имена файлов в качестве параметров… правильно, функции main!
Параметр int argc содержит количество переданных параметров. argc это сокращение от arguments count, количество аргументов, количество параметров. В программировании аргумент означает то же, что параметр.
А параметр char *argv[] относится к области знаний, которую я пока не затрагивал. К массивам. Массив это как бы набор пронумерованных переменных, и у них общее имя, а к нужной переменной из набора вы обращаетесь по номеру. По умолчанию, начальный элемент массива имеет нулевой номер, то есть идет нулевая ячейка массива, потом первая, потом вторая и так далее. Это важно помнить.
Что значит звездочка * после char, и при чем тут char, я расскажу позже. В С++ звездочка означает не только оператор умножения, но УКАЗАТЕЛЬ (pointer), однако до указателей мы еще не дошли.
Я отложу тему массивов на потом, покамест лишь скажу, что если мы хотим, в программе, получить название нашей программы, имя ее исполняемого файла, то оно содержится в нулевом элементе массива argv, и обращение к нему выглядит так:
argv[0]
То есть, после имени массива argv, мы в квадратных скобках указываем номер. Кстати, argv это сокращение от argument vector, а вектор это простейший, одномерный массив. О многомерности массивов мы поговорим позже. Сейчас это не нужно.
Все другие ячейки массива содержат остальные переданные программе параметры. Например, в файловом менеджере мы выделили два файла,
пейзаж.jpg и портрет.jpg
Запускаем с ними программу, которая называется “smotrelka” - в смысле, смотрелка картинок.
Что именно будет находиться в параметрах функции main, когда она запустится?
int main (int argc, char *argv[])
В argc у нас будет число 3. Напомню - начальный, нулевой параметр в массиве всегда содержит имя программы. А затем мы передали еще имена двух файлов, пейзаж.jpg и портрет.jpg.
Если в argc будет значение 1, это значит, что в массиве argv у нас занят только одна элемент, и это нулевой элемент с именем программы. Если в argc больше чем единица, это значит, что программе переданы еще какие-то параметры, в нашем примере - имена файлов. Итак, в
argv[0] у нас "smotrelka"
argv[1] у нас будет текст "пейзаж.jpg"
argv[2] у нас будет текст "портрет.jpg"
Но вернемся к нашей простейшей программе, ее функции main:
int main (int argc, char *argv[])
{
cout << "Привет!" << endl;
return 0;
}
Вторая строка вам уже ясна - наша программа возвращает в систему ноль, всё в порядке, и происходит выход из программы. Но что за эзотерическое
cout << "Привет!" << endl;
Какие-то двойные знаки минус, и прочее. Тьма сгущается. То массивы, векторы, то указатели, а теперь совсем странно. Неужели С++ не зря считают самым сложным языком программирования?
Вот в восьмидесятые годы программисту жить было просто. Писал себе на Бейсике и писал. В самом деле, это было просто. Это была эра процедурного программирования. Программисты писали себе программы в столбик, вызывали функции и радовались.
Но появилась новая мода - объектно-ориентированное программирование, позволившее программистам мыслить более приближенно к жизни. Зачатки объектно-ориентированного программирования есть и в процедурном, но обо все этом я расскажу в следующих сериях! Давайте пока, без углубления в тему, обсудим строку:
cout << "Привет!" << endl;
Объектно-ориентированное программирование позволяет использовать объекты. В жизни нас окружают не переменные и не функции, а объекты. Телевизор - объект. Он может показывать движущиеся картинки. К телевизору есть другой объект - пульт. Пульт может посылать инфракрасный сигнал датчику телевизора и тот включится или выполнит какую-то команду, например включит выбранный на пульте канал. Итак, объект пульт посылает данные на объект телевизор и тот выполняет некие действия, некие функции. Улавливаете сходство?
Данные - наши знакомые переменные. Действия - функции!
cout - это объект. Конечно же, это сокращение. От console out, консольный вывод. О да, объект вывода текста на экран!
Оператор «, два знака “меньше”, как бы псевдографическая стрелка, направление. И вот мы при помощи оператора “«” направляем в объект cout текст “Привет!”. Текстовые данные в С++ называются строками. Они обязательно должны быть заключены в двойные кавычки. Строка может занимать, при выводе на экран, несколько видимых строк. Но в контексте С++, любой набор из скольких-то букв это строка. По-английски string.
Есть еще line, линия - так на консолях традиционно тоже называется строка. Это когда рядом с компьютерами стояли толстенькие мониторы, на которых помещалось, например, по 40 строк из 25 символов каждая. Словом line, линия, называли и один набранный ряд на пишущей машинке.
У машинки была каретка - carriage, и при нажатии на клавишу, соответствующую компьютерной Энтер, происходил переход на следующую строку и возврат каретки в крайнее левое положение. По мере набора, каретка снова сдвигалась вправо.
Возврат каретки на английском называется carriage return, а новая строка - new line.
Посмотрим снова на выражение:
cout << "Привет!" << endl;
Вспомним, что речь идет о выводе на консоль, на терминал, а это по сути та же пишущая машинка. Мы буква за буквой, строка за строкой, выводим, печатаем на консоль текст.
И вот мы написали “Привет!” и хотим теперь сделать перевод виртуальной каретки на новую строку, чтобы, возможно, начать печатать что-то уже на другой строке.
Поэтому следом за “Привет” мы направляем на объект cout такую штуку, как endl. endl это сокращение от end of line, конец строки. Когда cout получает этот endl, то переводит виртуальную каретку назад и к новой строке.
На сегодня всё!
PayPal: peter.semiletov@gmail.com
биткоин: 1PCo2zznEGMFJey4qFKGQ8CoFK2nzNnJJf