Что изменится в процессе программы при присваивании

В компьютерном программировании оператор присваивания устанавливает и / или повторно -задает значение , хранящееся в ячейках памяти, обозначенных переменной именем ; другими словами, он копирует значение в переменную. В большинстве императивных языков программирования оператор присваивания (или выражение) является фундаментальной конструкцией.

Сегодня наиболее часто используемым обозначением для этой базовой операции стало x = expr (первоначально Superplan 1949–51, популяризировано Fortran 1957 и C ), за которым следует x: = expr (первоначально АЛГОЛ 1958, популяризированный Паскалем ), хотя есть много другие используемые обозначения. В некоторых языках используемый символ рассматривается как оператор (что означает, что оператор присваивания в целом возвращает значение), в то время как другие определяют присвоение как оператор (что означает, что его нельзя использовать в выражении).

Назначения обычно позволяют переменной сохранять разные значения в разное время в течение ее жизненного цикла и области действия. Однако некоторые языки (в основном строго функциональный ) не допускают такого «деструктивного» переназначения, так как это может означать изменения нелокального состояния. Цель состоит в том, чтобы обеспечить ссылочную прозрачность, то есть функции, которые не зависят от состояния некоторой переменной (переменных), но производят одинаковые результаты для заданного набора параметрических входных данных в любой момент времени. Современные программы на других языках также часто используют аналогичные стратегии, хотя и менее строгие, и только в определенных частях, чтобы уменьшить сложность, обычно в сочетании с дополнительными методологиями, такими как структурирование данных, структурное программирование и ориентация объекта.

Что произойдет с теми, кто еще не готов включиться в процесс трансформации?

Семантика

Операция присваивания — это процесс в императивном программировании, в котором различные значения связаны с конкретным именем переменной по прошествии времени. Программа в такой модели работает, изменяя свое состояние, используя последовательные операторы присваивания. Примитивы императивных языков программирования полагаются на присваивание для выполнения итерации. На самом низком уровне назначение осуществляется с помощью машинных операций, таких как MOVE или STORE .

Переменные являются контейнерами для значений. Можно поместить значение в переменную, а затем заменить его новым. Операция присваивания изменяет текущее состояние исполняемой программы. Следовательно, присвоение зависит от концепции переменных. В присвоении:

• выражение оценивается в текущем состоянии программы.
• Переменной назначается вычисленное значение, заменяющее предыдущее значение эту переменную.

Пример: Предполагая, что a является числовой переменной, присвоение a: = 2 * a означает, что содержимое переменной a удваивается после выполнения оператора.

Пример сегмента кода C :

int x = 10; float y; х = 23; y = 32,4f;

В этом примере переменная x сначала объявляется как int, а затем ей присваивается значение 10. Обратите внимание, что объявление и присваивание выполняются в одном операторе. Во второй строке y объявлен без присваивания. В третьей строке x повторно присваивается значение 23.

JavaScript — Полный Курс JavaScript Для Начинающих [11 ЧАСОВ]

Наконец, y присваивается значение 32,4.

Для операции присваивания необходимо, чтобы значение выражения было четко определено (это действительное rvalue ) и чтобы переменная представляет изменяемую сущность (это допустимое изменяемое (не const ) lvalue ). В некоторых языках, обычно динамических, нет необходимости объявлять переменную до присвоения ей значения. В таких языках переменная автоматически объявляется при первом назначении, а объем ее объявления зависит от языка.

Одиночное присвоение

Любое присвоение, изменяющее существующее значение (например, x: = x + 1 ), запрещено в чисто функциональных языках. В функциональном программировании назначение не рекомендуется в пользу однократного назначения, также называемого инициализацией. Одиночное присвоение является примером привязки имени и отличается от присвоения, описанного в этой статье, тем, что оно может быть выполнено только один раз, обычно при создании переменной; последующее переназначение не допускается.

Оценка выражения не имеет побочного эффекта , если она не изменяет наблюдаемое состояние машины и дает те же значения для того же ввода. Императивное присвоение может привести к побочным эффектам при разрушении и создании недоступности старого значения при замене его новым, поэтому в LISP и функциональное программирование оно называется деструктивным присвоением, аналогично деструктивному обновлению.

Одиночное присваивание — единственная форма присваивания, доступная в чисто функциональных языках, таких как Haskell, которые не имеют переменных в смысле императивных языков программирования, а имеют именованные константы ценности, возможно, комплексного характера с их элементами, постепенно определяемыми по запросу. Чисто функциональные языки могут обеспечить возможность параллельного выполнения вычислений , избегая узкого места фон Неймана последовательного выполнения одного шага во времени, поскольку значения не зависят друг от друга.

Нечеткие функциональные языки обеспечивают как одиночное присваивание, так и истинное присваивание (хотя истинное присваивание обычно используется с меньшей частотой, чем в императивных языках программирования). Например, в Scheme для всех переменных можно использовать как одиночное присвоение (с let ), так и истинное присвоение (с set! ), а для деструктивного обновления внутри списков предусмотрены специализированные примитивы., векторы, строки и т. д. В OCaml для переменных разрешено только одиночное присваивание с помощью синтаксиса let name = value ; однако деструктивное обновление может использоваться для элементов массивов и строк с отдельным оператором , а также для полей записей и объектов, которые были явно объявлены изменяемыми (что означает возможность изменения после их первоначального объявления) программистом.

Функциональные языки программирования, использующие одиночное присваивание, включают Clojure (для структур данных, а не переменных), Erlang (допускает множественное присваивание, если значения равны, в отличие от в Haskell), F#, Haskell, Lava, OCaml, Oz (для переменных потока данных, а не ячеек), Racket (для некоторых структур данных, например списков, а не символы), SASL, Scala (для vals), SISAL, Standard ML. Код без с возвратом Prolog можно рассматривать как явное однократное присваивание, явное в том смысле, что его (именованные) переменные могут находиться в явно неназначенном состоянии или устанавливаться ровно один раз. В Haskell, напротив, не может быть неназначенных переменных, и каждая переменная может рассматриваться как неявно установленная на свое значение (или, скорее, на вычислительный объект, который будет генерировать свое значение по запросу) при ее создании.

Значение присваивания

В некоторых языках программирования оператор присваивания возвращает значение, а в других — нет.

В большинстве языков программирования, ориентированных на выражения (например, C ), оператор присваивания возвращает присвоенное значение, допуская такие идиомы, как x = y = a , в котором оператор присваивания y = a возвращает значение a , которое затем присваивается x . В таком операторе, как while ((ch = getchar ())! = EOF) , возвращаемое значение функции используется для управления циклом при присвоении того же значения переменной.

В других языках программирования, например Схема, возвращаемое значение присваивания не определено, и такие идиомы недопустимы.

В Haskell нет назначения переменных; но операции, аналогичные присваиванию (например, присвоение полю массива или полю изменяемой структуры данных) обычно оцениваются по типу блока , который представлен как () . Этот тип имеет только одно возможное значение, поэтому не содержит информации. Обычно это тип выражения, который оценивается исключительно на предмет его побочных эффектов.

Вариантные формы присвоения

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

Расширенное присвоение

Случай, когда присвоенное значение зависит от предыдущего, настолько распространен, что многие императивные языки, в первую очередь C и большинство его потомков, предоставляют специальные операторы, называемые расширенным присваиванием, например * = , поэтому a = 2 * a вместо этого можно записать как a * = 2 . Помимо синтаксического сахара, это упрощает задачу компилятора, давая понять, что возможна модификация на месте переменной a .

Цепное присвоение

Оператор вида w = x = y = z называется цепным присвоением, в котором значение z присваивается нескольким переменным w, x, и y . Цепные присвоения часто используются для инициализации нескольких переменных, как в

a = b = c = d = f = 0

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

В некоторых языках программирования (например, C ) цепные присваивания поддерживаются, поскольку присваивания являются выражениями и имеют значения. В этом случае цепное присвоение может быть реализовано с помощью правоассоциативного присвоения, и присвоения происходят справа налево. Например, i = arr [i] = f () эквивалентно arr [i] = f (); i = arr [i] . В C ++ они также доступны для значений типов классов путем объявления соответствующего возвращаемого типа для оператора присваивания.

В Python операторы присваивания не являются выражениями и, следовательно, не имеют значения. Вместо этого связанные присваивания представляют собой серию операторов с несколькими целевыми объектами для одного выражения. Присваивания выполняются слева направо, так что i = arr [i] = f () вычисляет выражение f () , затем присваивает результат самой левой цели, i , а затем присваивает тот же результат следующей цели, arr [i] , используя новое значение i . По сути, это эквивалент tmp = f (); я = tmp; arr [i] = tmp , хотя фактическая переменная для временного значения не создается.

Параллельное присвоение

Некоторые языки программирования, такие как APL, Common Lisp,Go,JavaScript (начиная с версии 1.7), PHP, Maple, Lua, occam 2, Perl, Python, REBOL, Ruby и PowerShell позволяют назначать несколько переменных параллельно с синтаксисом вида:

a, b: = 0, 1

который одновременно присваивает 0 a и 1 b . Это чаще всего известно как параллельное присвоение ; он был введен в CPL в 1963 году под названием одновременное присвоение и иногда называется множественное присвоение, хотя это сбивает с толку при использовании с «одиночным назначением», поскольку это не противоположности. Если правая часть присвоения представляет собой единственную переменную (например, массив или структуру), функция называется распаковкой или деструктуризацией присвоения :

var list: = a, b: = list

Список будет распакован так, что 0 будет присвоен a , а 1 — b . Кроме того,

a, b: = b, a

меняет местами значения a и b . В языках без параллельного присвоения это должно быть написано для использования временной переменной

var t: = a a: = b b: = t

, поскольку a: = b; b: = a оставляет и a , и b с исходным значением b .

. Некоторые языки, такие как Go и Python, сочетают параллельное присваивание, кортежи и автоматическое распаковка кортежа, чтобы разрешить несколько возвращаемых значений из одной функции, как в этом примере Python,

def f (): return 1, 2 a, b = f ()

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

(a, b) = (b, a);
(строка, число) f () =>(«foo», 1); var (a, b) = f ();

Это обеспечивает альтернативу использованию выходных параметров для возврата нескольких значений из функции. Это относится к CLU (1974), и CLU помогло популяризировать параллельное присваивание в целом.

C # дополнительно допускает обобщенное назначение деконструкции с реализацией, определяемой выражением в правой части, поскольку компилятор ищет соответствующий экземпляр или extension Деконструировать метод для выражения, которое должно иметь выходные параметры для присваиваемых переменных. Например, один из таких методов, который дал бы классу , который проявляется в том же поведении, что и возвращаемое значение f () выше, будет

void Deconstruct (out string a, out int b)

В C и C ++ оператор запятой аналогичен параллельному присваиванию, позволяя выполнять несколько присваиваний в пределах одного оператора, записывая a = 1, b = 2 вместо а, b = 1, 2 . Это в основном используется в для циклов и заменяется параллельным присваиванием в других языках, таких как Go. Однако приведенный выше код C ++ не гарантирует идеальной одновременности, поскольку правая часть следующего кода a = b, b = a + 1 оценивается после левой стороны. В таких языках, как Python, a, b = b, a + 1 будет назначать две переменные одновременно, используя начальное значение a для вычисления нового b.

Присваивание против равенства

Использование знака равенства = в качестве оператора присваивания часто подвергалось критике из-за конфликта с равенством в качестве сравнения для равенства. Это приводит как к замешательству новичков в написании кода, так и к замешательству даже у опытных программистов при чтении кода. Использование равенства для присваивания восходит к языку Хайнца Рутисхаузера Суперплан, разработанному с 1949 по 1951 год и особенно популяризированному Фортраном:

Печально известный пример плохого Идея заключалась в выборе знака равенства для обозначения присвоения. Он восходит к Фортрану в 1957 году и был слепо скопирован армиями разработчиков языков. Почему это плохая идея? Потому что это опровергает вековую традицию, когда «=» обозначает сравнение на равенство, предикат, который является либо истинным, либо ложным. Но в Фортране это означало назначение, обеспечение равенства. В этом случае операнды находятся в неравном положении: левый операнд (переменная) должен быть равен правому операнду (выражению). x = y не означает то же самое, что y = x.

— Никлаус Вирт, Хорошие идеи, в Зазеркалье

Начинающие программисты иногда путают назначение с оператором отношения для равенства, поскольку » /w/Equality_(mathematics)»>равенство в математике и используется для присваивания во многих языках. Но присваивание изменяет значение переменной, а проверка на равенство проверяет, имеют ли два выражения одно и то же значение.

Сходство двух символов может привести к ошибкам, если программист забудет, в какой форме (» = «, » == «, » : = «) уместно, или ошибочно набирает » = «, когда предполагалось » == «. Это общая проблема программирования с такими языками, как C (включая одну известную попытку бэкдора в ядре Linux), где оператор присваивания также возвращает присвоенное значение (так же, как функция возвращает значение), и может быть правильно вложен в выражения. Если целью было сравнение двух значений в оператор if , например, присвоение с большой вероятностью вернет значение, интерпретируемое как логическое значение true, и в этом случае будет выполнено предложение then , что приведет к неожиданному поведению программы. Некоторые языковые процессоры (например, gcc ) могут обнаруживать такие ситуации и предупреждать программиста о потенциальной ошибке.

Обозначение

Двумя наиболее распространенными представлениями для копирующего присвоения являются знак равенства ( = ) и двоеточие равно ( : = ). Обе формы могут семантически обозначать либо оператор присваивания, либо оператор присваивания (который также имеет значение), в зависимости от языка и / или использования.

переменная = выражение	Fortran, PL / I, C (и потомки, такие как C ++, Java, и т. д.), оболочка Борна, Python, Go (присвоение предварительно объявленным переменным), R, PowerShell и т. д.
переменная: = выражение	АЛГОЛ (и производные), Simula, CPL, BCPL, Pascal (и потомки, такие как Modula ), Мэри, PL / M, Ада, Smalltalk, Эйфель, Оберон, Дилан, Seed7, Python (выражение присваивания), Go (сокращение для объявления и определения переменной), Io, AMPL, ML,AutoHotkey и т. Д.

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

переменная	Magik
переменная	F#, OCaml, R, S
переменная	R
assign («переменная», выражение)	R
переменная ← выражение	APL, Smalltalk, BASIC Programming
переменная =: выражение	J
переменная LET = выражение	BASIC
let variable: = expression	XQuery
установить переменную в выражение	AppleScript
установить переменную = выражение	оболочка C
Set-Variable переменная (выражение)	PowerShell
переменная: выражение	Macsyma, Maxima, Rebol, K
var переменная выражение	язык сценариев mIRC
ссылочная-переменная: — ссылочное-выражение	Simula

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

Некоторые платформы помещают выражение слева и переменную справа:

MOVE выражение TO переменная	COBOL
выражение → переменная	TI-BASIC, Casio BASIC
выражение ->переменная	POP-2, BETA, R
поместить выражение в переменную	LiveCode

Некоторые языки, ориентированные на выражения, такие как Lisp и Tcl единообразно используют префиксный (или постфиксный) синтаксис для всех операторов, включая присваивание.

(setf variable expression)	Common Lisp
(set! Variable expression)	Схема
установить выражение переменной	Tcl
выражение переменной!	Forth

См. также

• Оператор присваивания в C ++
• Оператор (программирование)
• Привязка имени
• Унификация (вычисления)
• Неизменяемый объект
• Константа-корректность

Источник: alphapedia.ru

КОМАНДЫ ПРИСВАИВАНИЯ, ВВОДА И ВЫВОДА

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

Каждая переменная характеризуется именем, типом и значением.

Имя переменной (идентификатор) всегда должно начинаться с латинской буквы, после которой могут следовать несколько латинских букв, цифр либо символ подчер- кивания «_», записанных без пробелов. Например: A, B1, sum, Name, Pr_3.

Тип переменной определяет диапазон допустимых значений.

Все переменные, используемые в программе, должны быть описаны в разделе описаний. Например:

A, B: integer; X:real;

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

На Паскале такого рода предписание обычно выражается командой присваивания, имеющей вид:

имя_переменной:=выражение_или_значение

Оператор присваивания (:=) предписывает выполнить выражение, заданное в его правой части, и присвоить результат переменной, идентификатор которой расположен в левой части. Переменная и выражение должны быть совместимы по типу.

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

Например, для оператора

Rezult:=A div В;

сначала выполняется целочисленное деление значения переменной А на значение переменной В, а затем результат присваивается переменной Rezult.

Примеры применения оператора присваивания: A:=22;

Пример, демонстрирующий работу команды присваивания. program primer;

var a:integer; begin

a:=5; writeln(‘a=’,a); a:=2*a;

В результате выполнения программы на экране в «окне вывода» появится следу- ющая информация об изменении значений переменной А:

Важно помнить: в результате выполнения команды присваивания предыдущее значе- ние переменной стирается.

Для выполнения операций ввода-вывода служат четыре процедуры: Read, Readln, Write, WriteLn.

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

Формат процедуры Read: Read (x1, x2, …, xn);

где x1, x2, …, xn- переменные допустимых типов данных.

Значения x1, x2, …, xn набираются минимум через один пробел на клавиатуре и высвечиваются на экране. После набора данных для одной процедуры Read нажимает- ся клавиша ввода Enter.

Значения переменных должны вводится в строгом соответствии с синтаксисом языка Паскаль. Если соответствие нарушено (например, х1 имеет тип Integer, а при вводе набирается значение типа Char), то возникают ошибки ввода-вывода. Сообще- ние об ошибке имеет вид: I/O error XX, где ХХ — код ошибки.

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

Процедура записи Write производит вывод числовых данных, символов, строк, булевских значений.

Формат процедуры Write: Write ();

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

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

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

WRITELN (Y:m:n:,X:k: I. );

где m и k- количество позиций, отведенных под запись значения переменных Y и X соответственно;

n и I — количество позиций, отведенных под запись дробной части чисел Y и X.

Пример 1. Найти сумму двух вещественных чисел.

Используемые переменные: x, y –вводимые числа (исходные данные), z – их сумма (результат)

Program primer; var

Writeln(‘Введите два числа X и Y:’);

Введите два числа X и Y:

Составить программу расчета значения функции.

Z = |cos х 4 – 3 tg х 2 |+0.8 sin yх 2 + 10 при любых значениях х и у. Результат вывести в виде: при х= и у=… z=…

Используемые переменные: x , y -аргументы, z – значение функции Program pr1;

Результат введите X Y 1 2

при x=1.00 y=2.00 z=11.59

Вводится вещественное число а. Не пользуясь никакими арифметическими опе- рациями, кроме сложения, получить 7а за четыре операции.

Используемые переменные: а –вводимое число,

b , c, d – вспомогательные переменные

Begin write(‘ введите a ‘);

Источник: znanio.ru

Основы кода

То есть, двоеточие и знак «равно», следующий сразу за ним, без пробелов. Присвоение происходит справа-налево: вначале вычисляется значение , указанное ПОСЛЕ этого оператора, затем оно присваивается переменной, указанной ДО оператора присваивания. Например:

var i: integer; //объявили переменную с типом integer — целое число begin i:= 3; //присвоили этой переменной значение 3

Значение , которое мы присваиваем переменной, может быть и сложным, составным. Мы можем указать не просто значение , а целое выражение , причем использовать в нем предыдущее значение самой переменной! Взгляните на пример:

var i: integer; begin i:= 3; i:= 2 * 5 + 36 * i; //сложное выражение

Тут мы объявили целочисленную переменную i . Этой переменной мы присвоили значение 3. Потом мы присвоили новое значение , которое сначала высчитывается компьютером из сложного выражения, а затем только присваивается переменной. Какое же значение теперь в i ? Давайте считать. Из уроков математики мы знаем, что сначала вычисляются такие операторы , как умножение и деление , а только потом — сложение и вычитание . То есть, сначала высчитывается 2 * 5 = 10 (для компьютера знак «*» — это умножение , если кто-то не знает). Затем вычисляется 36 * i , а i — это 3, мы делали это присваивание строчкой выше. Так что получаем 36 * 3 = 108 . Затем складываем эти значения: 10 + 108 = 118 . Именно столько и попадет, в конце концов, в переменную i .

Здесь у кого-то может возникнуть вопрос: а почему автор советовал давать переменным осмысленные имена, а сам назначил простое имя i ? Вопрос справедливый, отвечу так. Это — не реальная программа со множеством подпрограмм и переменных, это простой пример с одной переменной, и мы в любом случае, не запутаемся. Кроме того, переменная была назначена не для какой-то конкретной цели, а лишь для демонстрации присваивания ей значения. Поэтому и имя у переменной простое. В более сложных примерах и в лабораторных работах я постараюсь придерживаться своих же рекомендаций.

Если вы заметили, то в нашей программе мы также присваивали переменной не просто значение , а составное выражение :

MyName:= ‘Привет, ‘ + Edit1.Text + ‘!’;

Здесь мы строку » Привет, » соединяли с тем, что хранилось в поле ввода Edit1 , добавляли восклицательный знак, а результат уже присваивали переменной MyName . Обратите внимание, что после слов » Привет » мы вписали не просто запятую, а запятую с последующим пробелом. Если бы мы не указали этот пробел , то в результате текст сливался бы, а это не очень красиво:

Привет,Дмитрий!

Константы

Константы используются реже, чем переменные, однако в некоторых случаях они могут быть очень полезными.

В математике константа (лат. constanta — постоянная, неизменная) — некоторая величина, не изменяющая своё значение в рамках рассматриваемого процесса. В программировании константа имеет то же значение. Причем константы бывают двух типов: простые неименованные) и именованные.

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

i:= 3; //здесь 3 — это числовая константа s:= ‘строка’; // ‘строка’ — строковая константа

Конечно, число 3 всегда и везде будет равно 3, поэтому данное значение — константа. Такие простые константы мы применяем повсеместно, не особо задумываясь.

Именованная константа — несколько более сложное понятие. Фактически, это такая же ячейка оперативной памяти, как и переменная , но значения в этой ячейке не могут меняться. Применение таких констант полезно в двух случаях:

1. Когда не хочется запоминать реального значения, или когда оно довольно длинное. Например, число ПИ равно 3,141 592 653 589 793 238 462 643 383 279 502 88. Хочется вам запоминать такое значение? Не проще ли определить константу pi и записать в нее это число? Тогда в дальнейшем, вместо указания этого числа мы будем указывать константу pi . Компилятор сам подставит нужное значение вместо имени этой константы.
2. Когда какое-то значение используется в программе без изменений, но со временем оно может стать другим. Например, минимальная зарплата (МРОТ — Минимальный Размер Оплаты Труда) на 2013 год принята в размере 5205 руб. Наша программа, к примеру, вычисляет зарплату сотрудников, для этого МРОТ может умножаться на различные коэффициенты, например, коэффициент выслуги лет. Поскольку такое вычисление будет многократным — для каждого сотрудника отдельно, да еще с различными условиями (отпуск, больничный, премия и т.п.), то разумно объявить константу mrot со значением 5205, и в дальнейшем использовать ее вместо реального значения. Почему такой подход удобен? Во-первых, наша программа может попасть в другой регион, а там может оказаться свой размер МРОТ. Например, в Ленинградской области принят МРОТ в размере 6800 руб., а в г. Москве и вовсе 12200 руб. Во-вторых, на 2014 год размер МРОТ наверняка увеличится, а значит, его значение изменится. В обоих этих случаях достаточно будет изменить значение константы в начале модуля, и во всех местах кода, где эта константа применяется, автоматически будет использовано новое значение. Нам не придется кропотливо выискивать по всему коду, где же мы использовали при расчетах размер МРОТ, чтобы вписать туда новое значение.

Константа — область оперативной памяти, значение в которой остается неизменным, пока программа работает.

Стоит отметить, что когда программа завершает свою работу, все ячейки, выделенные под переменные и под константы , очищаются. Вернее, перестают учитываться операционной системой. То есть, если другая программа захочет их использовать, Windows это разрешит. Но до тех пор, пока эта программа не запишет в ячейки уже свои значения, там будет «мусор» — набор непонятных данных. Вот почему очень важно не только объявлять переменные ( константы ), но и присваивать им начальные значения.

Константы объявляются в разделе const (англ. constants — постоянные, константы ), причем этот раздел должен располагаться до раздела var . Объявление константы и присвоение ей значения в отличие от переменных, происходит одновременно:

const mrot = 5205;

Здесь мы создали раздел констант, в котором объявили константу mrot , и сразу же присвоили ей значение 5205. Как видите, вместо оператора присваивания » := «, как это было у переменных, здесь используется простой знак «равно», а тип константы не указывается. Компилятор сам, в зависимости от указанного значения, присваивает константе наиболее подходящий тип.

Вернемся к нашему примеру, и снова доработаем код события нажатия на кнопку:

procedure TfMain.Button1Click(Sender: TObject); const priv = ‘Привет, ‘; var MyName: String; begin MyName:= priv + Edit1.Text + ‘!’; ShowMessage(MyName); MyName:= ‘Рады вас видеть, ‘ + Edit1.Text + ‘!’; ShowMessage(MyName); end;

В этом примере мы объявили константу priv и присвоили ей текст — начало приветствия. Причем раздел const мы поместили до раздела var . В строке

MyName:= priv + Edit1.Text + ‘!’;

компилятор вместо » priv » подставит значение » Привет, » и мы получим прежний текст приветствия.

Комментарии

Когда кода очень много, программист легко может в нем запутаться. Чтобы этого не произошло, в Паскале предусмотрены комментарии.

Комментарий — это пояснительный текст, который добавляется программистом к исходному коду и игнорируется компилятором.

То есть, программист сам себе оставляет комментарии> — заметки, указывающие, что происходит в данном участке кода, для чего создан данный элемент, что будет происходить дальше и т.п. При сборке программы компилятор FPC игнорирует весь этот текст и не включает его в программу. Комментарий остается лишь в исходных кодах.

Комментарии улучшают восприятие кода программистом, а если проект разрабатывается не одним программистом, а группой, тут без комментариев и вовсе не обойтись. Говорят, в компании Microsoft, когда принимают на работу нового программиста, смотрят на стиль его кода. И если там комментариев меньше, чем 1/3 от всей программы, ему отказывают в вакансии.

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

Комментарии бывают однострочными и многострочными.

Однострочный комментарий начинается с символов » // » и может располагаться как на отдельной строке, так и после действующего оператора. Примеры мы уже видели:

i:= 3; //присвоили этой переменной значение 3

Здесь текст после » // » — однострочный комментарий. Мы могли бы расположить его и на отдельной строке:

//присваиваем переменной новое значение: i:= 10;

Имейте в виду, что если вы используете какой-то оператор после однострочного комментария на той же строке, для FPC это будет считаться продолжением комментария, и оператор не будет выполнен:

//присваиваем переменной новое значение: i:= 10;

Иногда однострочные комментарии применяются для визуального отделения одной смысловой части кода от другой:

//************************************************* …какой-то код //************************************************* Или так: //———— НАЧАЛО БЛОКА КОДА —————————— …какой-то код //———— КОНЕЦ БЛОКА КОДА ——————————-

В общем, для улучшения читабельности программы, после » // » вы можете использовать собственные разделители.

Многострочный комментарий. Когда комментарий содержит много пояснительного текста, его делают многострочным. Для этого его помещают в фигурные скобки » «. Всё, что находится внутри таких скобок, считается комментарием:

Также в Паскале вместо фигурных скобок для многострочного комментария можно применять символы комментариев языка С: » (*…*) «:

(* Пример многострочного комментария в стиле С/С++ *)

Какие комментарии применять — дело вкуса. Их можно и комбинировать между собой, в серьезных проектах часто так и делают.

Совет: комментарии — это хорошо, однако не переусердствуйте и не давайте совсем уж очевидных комментариев.

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

var i: integer; //объявили переменную с типом integer — целое число begin i:= 3; //присвоили этой переменной значение 3

Теперь вы и без комментариев сможете разобраться в коде этого примера, а значит, комментарии здесь можно и не давать.

Источник: intuit.ru