#2 Литералы и Вывод данных на экран (в консоль). Первое знакомство с Write и Writeln. Аргументы процедуры. Паскаль

Литералы -- это данные записанные непосредственно в программном коде, мы можем посмотреть на них в конкретной строке программы и сказать, что это число или строка или символ и т.д. И какая именно число, строка или символ т.д. Значение литерала нельзя изменить, так как он сам и есть значение.

Типы литералов

Литералы бывают разных типов и каждый литерал соответствует какому-то типу данных, но о типах данных вообще мы поговорим позднее. Пока же рассмотрим литералы трёх типов:

  1. Строковые литералы
  2. Символьные литералы
  3. Числовые литералы

Строковые литералы

Строковые литералы -- это строки текста. Внутри программы, написанной на языке Паскаль, они всегда берутся в одинарные кавычки, например:

'Два чувства дивно близки нам'

Следует отметить, что строковый литерал всегда размещается на одной строке, и перенос её внутри литерала приведёт к ошибке при запуске программы.

Символьные литералы

То же самое, что и строки, только состоят из одного символа, заключенного в одинарные кавычки.
Цифра взятая в кавычки с двух сторон также трактуется как символ.
Примеры символьных литералов (с помощью комментариев к коду, добавим справа пояснения):

'a'
'f'  // символ буквы

'Б'

'8'  // символ цифры

'9'

'#'

'-'

'_'

' ' // одиночный пробел тоже является в символьным литералом

Последним в списке примеров символьных литералов приведён пробел, это просто символ пробела окружённый одинарными кавычками

Числовые литералы

Числовые литералы можно разделить на:

  1. Целочисленные -- это любые целые числа -- положительные, например:
    1255

    или отрицательными, например:

    -53456
  2. Литералы вещественных чисел, которые тоже могут быть положительными или отрицательными, причём в качестве разделителя дробной и целой части используется точка. Например:
    55.678

    или:

    -12656.3

Далее рассмотрим использование литералов для вывода данных.

Вывод данных на экран с помощью write() и writeln()

В этом разделе мы с вами начнём писать первые работающие строки программного кода на языке Паскаль.

Первая программа -- Привет Мир!

Следуя уже довольно старой и всё такой же доброй традиции, выполним нашу первую программу, поприветствовав мир:

begin
   writeln('Привет Мир!'); // или: writeln('Privet Mir!');   
end.

Запустите этот пример (не забывая о том для чего нужны и что значат комментарии и операторные скобки). Вывелось ли приветствие?

Если окно в котором оно выводится слишком быстро закрывается, используйте приём для удержания консоли (просто запомните его, позже мы объясним как это работает):

begin
   writeln('Привет Мир!'); // или: writeln('Privet Mir!');   

  readln(); readln(); 
end.

Если строка выводится в виде абракадабры, то просто перепишите строковый литерал английскими буквами, как это указано в комментарии к строке вывода приветствия (просто передаём звуки русского языка латинскими символами, переводить фразу на английский не требуется).

Далее в листингах (фрагментах кода), мы будем опускать (не писать каждый раз) операторные скобки, подразумевая, что уже пишем внутри тела программы. Но для запуска этих фрагментов в вашей среде разработки, они должны быть окружены ими.

Обязательно запускайте на своём компьютере все примеры, которые будут встречаться далее.

write() и writeln() -- стандартные процедуры вывода данных


Процедура
-- это подпрограмма, которую вызывает основная программа, чтобы подпрограмма совершила какие-то действия необходимые основной программе.

Write() и Writeln() -- две стандартные (то есть разработанные создателями языка) процедуры в Паскаль, которые позволяют выводить на экран переданную в них информацию, или говорят "переданные им аргументы".

Аргументы -- это значения, которые передаются в процедуру, будучи перечисленными в коде программы внутри скобок после имени процедуры, например:

writeln('a', 123, '7'); // вызов процедуры writeln  с тремя аргументами

Даст нам в консоли текст:

a1237

Обратите внимание, что после вызова любой процедуры обычно ставится точка с запятой.

Чтобы показать, что какое-то слово является именем процедуры в обычном тексте (учебника, например) и коде программы после имени процедуры всегда открывают и закрывают операторные скобки вне зависимости от того, перечисляются ли внутри этих скобок какие-то аргументы или нет.

Вызов процедуры с указанным именем

Чтобы вызвать какую-то процедуру необходимо знать:

  1. её имя
  2. число её аргументов и их тип

Например ,пусть у нас есть выдуманная процедура с именем, скажем, $test()$ и мы знаем, что она принимает на вход два аргумента: один целочисленный аргумент и один литерал, тогда вызвать её можно с помощью такой строки в теле программы:

test(2, 'c');

или:

test(2, '2');

Или даже передав в качестве первого аргумента переменную нужного типа:

a: integer;
begin
  a := 5;
  test(a, '#');

write() & writeln()

Теперь перейдём непосредственно к обсуждению write() и writeln().
Общее:

  • И write() и writeln() служат для вывода в консоль информации.
    Например, ввод чисел:
    write(22);
    write(22.23); // выводим вещественное число

    или символов:

    write('2');
    writeln('K'); 
    

    Или строк (строковый литералов):

    write('Земля вертится');
    writeln(' Спички заканчиваются'); 
    
  • И write() и writeln() принимают любое число аргументов, то есть если мы перечислим через запятую много литералов одного или разных типов, все они будут выведены один за другим на экран.

    Например:

    write('Земля вертится', ' Спички заканчиваются');
    writeln('Земля вертится', ' Спички ', 'заканчиваются'); 

Отличие:

  • write() просто выводит на экран переданные ему аргументы.
  • writeln() же выводит переданные аргументы и переводит курсор на новую строку. То есть любой следующий вызов процедуры вывода данных начнёт свой вывод уже со следующей строки.

Таким образом сравним работу фрагментов кода:

write('Привет');
write('Мир'); 

и

writeln('Привет');
write('Мир'); 

В чем разница между результатами, если запустить их? Обратите внимание в каком случае произошёл перенос строки, а в каком нет.

Пустой writeln() и пустой write() для перевода строки

Следует отметить, что по данному выше описанию работы writeln() и write() можно сказать, что вызванный без аргументов write():

write(); // ничего не делает, выводить нечего

не делает вообще ничего, а вот пустой writeln() позволяет перенести курсор на новую строку:

writeln(); // выводить нечего, но ещё нужно перенести курсор
{на новую строку
 не зависимо от того были ли переданы аргументы}

(заметьте, что в последнем примере кода использовались и однострочные и многострочные комментарии)

Вывод литералов разного типа:

write(5); // вывод числового литерала
write(5.5); // вывод числового вещественного литерала
write('5'); // вывод символа пятёрки
write('5rwer'); // вывод строки (строкового литерала)

Примеры вывода одного и того же разными способами

Паскаль не зря называют языком программирования, как и обычном человеческом языке "сказать" тут можно одно и то же разными способами. Поэтому очень важно понимать, всё что написано в примерах, которые встречаются в этом тексте. Если вам что-то неясно -- задавайте вопросы.

Вывод одной строки -- разными способами

Пусть у нас есть задача вывести в консоль такой текст:

b = 5, тогда  b - 2 = три

Итак, рассмотрим разные способы:

  1. Проще всего напечатать этот текст в виде строкового литерала:
     writeln('b = 5, тогда  b - 2 = три');

    -- следует отметить, что запятая внутри кавычек не разделяет аргументы, а рассматривается Паскалем как обычный символ внутри строкового литерала.

  2. Тут же стоит отметить, что то же самое мы получим, если передадим в процедуру частями:
    writeln('b = 5, то', 'гд', 'а  b - 2', ' = три'); // четыре аргумента
  3. Далее, два примера точно также отработают и для write(), скажем второй случай:
    write('b = 5, то', 'гд', 'а  b - 2', ' = три');
  4. Также write() можно было бы вызвать дважды (или другое число раз, просто разбив строку на части):
    write('b = 5, тогда'); // выводим начало 
    write('  b - 2 = три'); // выводим оставшуюся часть
  5. Всегда можно присоединять к уже выведенному по одному символу, например используем для выполнения задачи два строковых и два символьных литерала:
    write('b = 5, тогда'); // выводим начало 
    write('  b - 2 = т');
    write('р'); // к уже выведенному добавляем букву эр
    write('и');
  6. Числа и цифры можно выводить с помощью числовых литералов -- то есть без кавычек, например:
    write('b = ', 5 ', тогда  b -', 2, ' = три');

ПРИМЕЧАНИЕ: Надо понимать, что множественные вызовы write() и передача всё тех же аргументов через запятую -- это одно и то же, а вот множественный вызов writeln() и передача аргументов в один writeln() через запятую -- не одно и то же, так как после каждого вызова writeln происходит перенос курсора на новую строку.

Вывод многострочного текста

Если требуется вывести многострочный текст, то одним или несколькими write() не обойтись, ведь нужно будет как-то переносить курсор на новую строку, а write этого делать не умеет, поэтому нам придётся использовать в том числе и writeln().

Пусть нам требуется вывести в косоль такого аски-арт робота:

        ; 
       ["]
      /[_]\
       ] [

По сути это текст из нескольких строк, где встречаются пробелы другие символы:
Разные способы вывода:

  1. В отличии от предыдущих примеров тут уже не обойтись передачей всего текста в один строковый литерал, так как этот робот многострочный, поэтому чтобы вывести его построчно будем использовать серию writeln():
    writeln('        ; ');
    writeln('       ["]');
    
    writeln('      /[_]\');
    writeln('       ] [');
    
  2. После вывода последней строки перенос курсора не обязателен, и потому можно использовать write():
    writeln('        ; ');
    writeln('       ["]');
    
    writeln('      /[_]\');
    write('       ] ['); // печатаем без переноса
    
  3. Если вы почему-то хотите вывести какую-то очередную стоку с помощью write() и после неё идёт текст, который должен начинаться с новой строки, то не забывайте дополнительно вызвать пустой writeln(), например:
    writeln('        ; '); // вывод и перенос  строки
    writeln('       ["]');  // вывод и перенос  строки
    write('      /[_]\');  // просто  вывод   строки
    writeln(); //  просто перенос строки
    write('       ] ['); // печатаем без переноса

Задачи для самостоятельного решения

    Ответьте на вопросы (письменно):
  1. Литералы какого типа вы знаете? Чем они отличаются друг от друга при записи
  2. Что такое процедура? Что такое аргументы процедуры?
  3. Пусть у вас есть процедура с именем $abc()$ и она принимает четыре аргумента - первые два целочисленные, и третий символьный и четвертый строковый. Запишите её вызов в теле программы в качестве аргументов передав литералы соответствующего типа.
  4. Чем отличается write от writeln()?
  5. Если ли разница между передачей многих аргументов во write(), например:
    write(5, 6, 8);

    и вызовом этой процедуры несколько раз с каждым из этих аргументов, например:

    write(5);
    write(6);
    write(8);

    ? Будет ли разница между выведенными на экран текстами, если в них write() заменить на writeln()?
    (если не можете ответить сходу -- запустите по очереди оба примера ,сравните результат и снова почитайте объяснения выше)

  6. ПРИМЕЧАНИЕ: когда будете решать следующие ниже задачи, можете привести все решения в теле одной программы, просто закомментировав то. что уже работает, ваш код будет выглядеть как-то так:

    begin
    //  write(7); // вывод числового литерала (работает, закомментируем)
         write('9'); // вывод символьного литерала 
     {предыдущую строку можно тоже закомментировать 
      и продолжить писать решения ниже}
    end.

    Когда же будете показывать работу программы расскомментируйте те строки, работу которых хотите продемонстрировать. Например показываем работу первой строчки тела программы (в предыдущем же примере мы показывали работу второй строки):

    begin
       write(7); // вывод числового литерала 
    //     write('9'); // вывод символьного литерала 
     {предыдущую строку можно тоже закомментировать 
      и продолжить писать решения ниже}
    end.

    Далее решите задачи запуская код программы, в теле которого:

  7. Выведите на экран число 2 как числовой литерал
  8. Выведите на экран число 2 как символ
  9. Выведите на экран 22 как число
  10. Выведите на экран 222 как строку
  11. Выведите на экран 222 -- первую цифру как число, а остальное как строку.
  12. Пусть нам требуется вывести на экран строку (ту же, что мы рассматривали выше в примерах):
    b = 5, тогда  b - 2 = три

    Выведете этот на экран эту строку (напишите в одной программе решения всех пунктов, просто закрывая комментариями, тот код, что уже работает):

    1. С помощью 1 аргумента -- литерала строкового типа
    2. С помощью 2-х аргументов-литералов любого типа одним вызовом write().
    3. С помощью вывода всей строки, кроме последнего символа, потом уже этого последний символ.
    4. Так, чтобы одна цифра была числовым литералом, вторая символом, а всё остальное чем угодно.

    ПРИМЕЧАНИЕ: После выполнения всех четырёх пунктов на экране (в консоли) вы должны получить (4 строки):

    b = 5, тогда  b - 2 = три
    b = 5, тогда  b - 2 = три
    b = 5, тогда  b - 2 = три
    b = 5, тогда  b - 2 = три
    
  13. В примерах выше мы выводили на экран робота, выведете его же, но антенну (для которой используется точка с запятой) выведете отдельной командой как символьный литерал, всё же остальное любым способом.
  14. Выведите хвост котика:
    \    /\ 
     )  ( *)
     (  /  )
      \(__)|
    

    с помощью отдельных символов, а всё остальное как угодно.