Уравнение Шредингера

Уравнением движения в квантовой механике, описывающим движение микрочастиц в различных силовых полях, должно быть уравнение, из которого вытекали бы волновые свойства частиц. Оно должно быть уравнением относительно волновой функции Ψ(х , у , z , t ), так как величина │ Ψ│ 2 определяет вероятность пребывания частицы в момент времени в объеме.

Основное уравнение сформулированоЭ. Шредингером: уравнения не выводится, а постулируется.

Уравнение Шредингера имеет вид:

- ΔΨ + U (x ,y , z , t )Ψ = iħ , (33.9)

где ħ=h/ (2π ), т -масса частицы, Δ-оператор Лапласа, i - мнимая единица,U (x ,y ,z ,t ) - потенциальная функция частицы в силовом поле, в котором она движется, Ψ(x ,y , z , t ) - искомая волновая функция частицы.

Уравнение (32.9) является общим уравнением Шредингера . Его также называют уравнением Шредингера, зависящим от времени. Для многих физических явлений, происходящих в микромире, уравнение (33.9) можно упростить, исключив зависимость Ψ от времени, иными словами, найти уравнение Шредингера для стационарных состояний - состояний с фиксированными значениями энергии. Это возможно, если силовое поле, в котором частица движется, стационарно, т. е. функцияU (x ,y ,z ,t ) не зависит явно от времени и имеет смысл потенциальной энергии.

∆ Ψ + (E -U )Ψ = 0. (33.10)

Уравнение (33.10) называется уравнением Шредингера для стационарных состояний .

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

33.5. Частица в одномерной прямоугольной «потенциальной яме с бесконечно высокими «стенками»

Свободная частица - частица, движущаяся в отсутствие внешних полей. Так как на свободную частицу (пусть она движется вдоль оси х ) силы не действуют, то потенциальная энергия частицы U (х ) = соnstи ее можно принять равной нулю. Тогда полная энергия частицы совпадает с ее кинетической энергией. Энергия свободной частицы может принимать любые значения, т. е. ее энергетический спектр является непрерывным. Свободная квантовая частица описывается плоской монохроматической волной де Бройля, и все положения свободной частицы в пространстве являются равновероятными.

Проведем качественный анализ решений уравнения Шредингера применительно к свободной частице в одномерной прямоугольной «потенциальной яме» с бесконечно высокими «стенками» (рис.33.1). Такая «яма» описывается потенциальной энергией вида (для простоты принимаем, что частица движется вдоль оси х )

∞, х < 0

U (x ) = {0, 0 ≤ х ≤ l }(33.11)

∞, х > 1

где l - ширина «ямы», а энергия отсчитывается от ее дна (рис.33.1).

Уравнение Шредингера для стационарных состояний в случае одномерной задачи запишется в виде

+ (Е- U )Ψ = 0. (33.12)

По условию задачи (бесконечно высокие «стенки»), частица не проникает за пределы «ямы», поэтому вероятность ее обнаружения (а следовательно, и волновая функция) за пределами «ямы» равна нулю. На границах «ямы» (при х =0 и х=l ) непрерывная волновая функция также должна обращаться в нуль. Следовательно, граничные условия в данном случае имеют вид

Ψ(0)=Ψ(l )=0. (33.13)

В пределах «ямы» уравнение Шредингера сведется к уравнению

+ Е Ψ = 0. (33.14)

Стационарное уравнение Шредингера, описывающее движение частицы в «потенциальной яме» с бесконечно высокими «стенками», удовлетворяется только при собственных значениях Е п зависящих от целого числа п .

Е п = ,( n= 1, 2, 3, …).(33.15)

Ввод-вывод

Финкции вывода:

%d-целое число со знаком

%u- целое число без знака

%f-вещественное число

%с-символ

Финкции ввода:

24 Типы данных языка Си.

long int counter;

Арифметические константы.

или в шестнадцатеричном виде:

\а сигнал-звонок

\\ обратная наклонная черта

\b возврат на шаг (забой)

\f перевод страницы

\n новая строка

\r возврат каретки

\? знак вопроса

\" одиночная кавычка

\” двойная кавычка

\ooo восьмеричный код

\xhh шестнадцатеричный код

Будьте внимательны и помните, что символьная константа и строка, содержащая один символ, не одно и то же: "х " не то же самое, что "х". Запись "х" обозначает целое значение, равное коду буквы х из стандартного символьного набора, а запись "х" - массив символов, который содержит один символ (букву х) и " \0".

Переменные и их описания.

В Си любая переменная должна быть объявлена раньше, чем она будет использована; обычно все переменные объявляются в начале функции перед первой исполняемой инструкцией. В объявлении описываются свойства переменных. Оно состоит из названия типа и списка переменных, например:

int fahr, celsius;

int lower, upper, step;

В своем объявлении переменная может быть инициализирована, как, например:

char esc = " \ \" ;

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

const double e = 2.71828182845905;

const char msg = "предупреждение: ";

Применительно к массиву квалификатор const указывает на то, что ни один из его элементов не будет меняться. Указание const можно также применять к аргументу-массиву, чтобы сообщить, что функция не изменяет этот массив:

int strlen(const char);

Реакция на попытку изменить переменную, помеченную квалификатором const, зависит от реализации компилятора.

Унарные операции в Си.

Оператор инкремента ++ добавляет 1 к своему операнду, а оператор декремента -- вычитает 1. Необычность операторов ++ и -- в том, что их можно использовать и как префиксные (помещая перед переменной: ++n), и как постфиксные (помещая после переменной: n++) операторы. В обоих случаях значение n увеличивается на 1, но выражение ++n увеличивает n до того, как его значение будет использовано, а n++ - после того.

Побитовые операции в Си.

В Си имеются шесть операторов для манипулирования с битами. Их можно применять только к целочисленным операндам, т. е. к операндам типов char, short, int и long, знаковым и беззнаковым.

& - побитовое И.

| - побитовое ИЛИ.

^ - побитовое исключающее ИЛИ. << - сдвиг влево.

>> - сдвиг вправо.

~ - побитовое отрицание (унарный).

Оператор & (побитовое И) часто используется для обнуления некоторой группы разрядов. Например,

n = n & 0177 обнуляет в n все разряды, кроме младших семи.

Оператор | (побитовое ИЛИ) применяют для установки разрядов; так, х = х! SET_ON устанавливает единицы в тех разрядах х, которым соответствуют единицы в SET_ON.

Поразрядные операторы & и | следует отличать от логических операторов && и ||, которые при вычислении слева направо дают значение истинности. Например, если х равно 1, а у равно 2, то х & у даст нуль, а х && у - единицу.

Оператор ^ (побитовое исключающее ИЛИ) в каждом разряде установит 1, если соответствующие разряды операндов имеют различные значения, и 0, когда они совпадают.

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

Унарный оператор ~ поразрядно "обращает" целое т. е. превращает каждый единичный бит в нулевой и наоборот. Например, х = х & ~077 обнуляет в х последние 6 разрядов.

Условные операторы в Си.

Условный оператор if

Синтаксис:

а) сокращённая форма

if (<выр>) <оператор1>;

б) полная форма

if (<выр>) <оператор1>;

else <оператор2>;

Выражение <выр> может быть арифметическим, логическим или отношением. Если значение <выр> не равно нулю, то исполняется <оператор1>.

В полной форме если <выр> равно нулю, то исполняется <оператор2>.

Условная трёхместная операция (? :)

Синтаксис:

<выр1> ? <выр2> : <выр3>;

Первым вычисляется значение <выр1>.

Если оно не равно нулю (истинно), то вычисляется значение <выр2>. Значение <выр3> не вычисляется.

Если значение <выр1> равно нулю (ложно), то вычисляется значение <выр3>. Вычисление значения <выр2> не производится.

Sign = x<0 ? -1: 1;

35. Оператор-переключатель.

Переключатели

Синтаксис:

switch(<выр>)

case <константа_1> : <операторы_1>;

case <константа_2> : <операторы_2>;

case <константа_L> : <операторы_L>;

default: <операторы>;

При входе в переключатель вычисляется значение <выр>. Если оно совпадает с одной из констант, то выполняются операторы, указанные в соответствующей ветви case. Например, если <выр>==<константа_L>, то выполняются <операторы_L>.

Если значение <выр> не совпадает ни с одной из констант, то выполняются операторы, указанные после default.

Если среди операторов исполняемой ветви нет какого-либо оператора перехода (break, goto, return, exit()), то исполняются операторы следующей ветви.

Если среди операторов исполняемой ветви встретился оператор break, то управление передаётся оператору, следующему за переключателем. Если встретился оператор goto, то управление передаётся на указанную метку.

Ветвь default, может располагаться в любом месте группы ветвей переключателя.

switch (operand) {

case MULTIPLY: x *= y; break;

case DIVIDE: x /= y; break;

case ADD: x += y; break;

case SUBTRACT: x -= y; break;

case INCREMENT2: x++;

case INCREMENT1: x++; break;

case MOD: printf("Not done\n"); break;

default: printf("Bug!\n");

Если operand == MULTIPLY, то будет выполнено x *= y; и обработка переключателя (и исполнение программы) завершится.

Если operand == INCREMENT2, то будет выполнено x++; x++; и обработка переключателя завершится.

Если operand примет значение EXPONENT, ROOT или MOD, то будет исполнено printf("Not done\n"); break;

36. Операторы цикла в Си.

Параметрический цикл For

Синтаксис:

for ([<выр1>]; [<выр2>]; [<выр3>]) <оператор>;

<оператор> повторно исполняется до тех пор, пока <выр2> не примет значения 0 («ложь»).

ДО ПЕРВОЙ итерации цикла вычисляется значение <выр1>. Обычно это используют для инициализации счётчика цикла. Затем вычисляется значение <выр2>.

ПОСЛЕ КАЖДОЙ итерации вычисляется значение <выр3>. Обычно это используют для увеличения значения счётчика цикла. Затем вычисляется значение <выр2>.

<выр1> и <выр3> могут состоять из нескольких выражений, разделённых запятыми.

Все параметры заголовка цикла необязательные, но оба разделителя ‘;’ должны иметь место. Т.е., допустимы формы

For(<выр1>;;) <оператор>;

For(;<выр2>;) <оператор>;

For(;;<выр3>) <оператор>;

For(<выр1>;;<выр3>) <оператор>;

Если отсутствует <выр2>, то его значение считается равным 1 («истина»).

Цикл с предусловием while

Синтаксис:

while (<выр>) <оператор>;

<оператор> <выр> <выр> вычисляется ПЕРЕД каждой итерацией.

Цикл с постусловием do ... while

Синтаксис:

do <оператор> while (<выр>);

<оператор> повторно исполняется пока значение <выр> остаётся не равным нулю. Значение <выр> вычисляется ПОСЛЕ каждой итерациеи.

Оформление функций.

39. Структура Си-программы. Разновидности переменных.

void main() /* главная программа */

int x,y,z; /* объявление переменных целого типа */

x=5; y=6; /* операторы присваиания */

printf("сумма=%d\n",z); /* стандартная функция вывода из библ. */

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

Переменные могут хранить разные данные, и от этого зависит их тип. В C++ существует довольно много различных типов переменных, они делятся на целые, дробные, логические и символьные. Существует также отдельный тип для строк, но о нем отдельный разговор.

К целым типам относятся такие типы, как int, short (short int) и long. Переменные типа int занимают в памяти 32 бита. Переменные short в два раза "короче", о чем свидетельствует название. Они занимают в памяти 16 бит. Переменные типа long, соответственно, в два раза длиннее, занимают в памяти 64 бита.

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

К дробным типам относятся float и double - дробные числа одинарной и двойной точности соответственно. Переменные первого типа занимают в памяти 32 бита, второго типа - 64.

Логический тип всего один, и называется он bool. Как следует из названия, этот тип предназначен для хранения логических значений "истина" (true) или "ложь" (false).

Символьный тип тоже единственный. Он называется char и может хранить один символ, точнее, его номер в кодировке ASCII, в этом отношении этот тип близок целым типам. Диапазон значений типа char - целые числа от -128 до 127 (от 0 до 255 для unsigned char), то есть все символы латинского и национального алфавитов, цифры, знаки препинания и специальные символы, такие как переход на следующую строку и т.д. При этом следует помнить, что одиночные символы в C++ заключаются в апострофы.

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

Адресная арифметика.

может быть различной:

результат типа int*

Указатели и функции.

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

Указатель – это объект, содержащий адрес другого объекта и позволяющий косвенно

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

динамически созданными объектами, для построения связанных структур данных, таких,

как связанные списки и иерархические деревья, и для передачи в функции больших

объектов – массивов и объектов классов – в качестве параметров.

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

представление не зависит от внутреннего типа: и размер памяти, занимаемый объектом

типа указатель, и диапазон значений у них одинаков5. Разница состоит в том, как

компилятор воспринимает адресуемый объект. Указатели на разные типы могут иметь

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

может быть различной:

памяти 1000-1003 (в 32-битной системе);

памяти 1000-1007 (в 32-битной системе).

Когда мы применяем операцию взятия адреса (&) к объекту типа int, то получаем

результат типа int*

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

Форматный ввод-вывод.

Две функции: printf для вывода и scanf для ввода (следующий раздел) позволяют преобразовывать численные величины

в символьное представление и обратно. Они также позволяют генерировать и интерпретировать форматные строки. Функция

printf(control, arg1, arg2, ...)

преобразует аргументы в текстовую форму в соответствии с форматами, заданными в управляющей строке control, и выдает

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

ются в выходной поток, и спецификации преобразований, каждая из которых вызывает преобразование и печать очередного аргу-

мента printf.

Каждая спецификация преобразования начинается с символа "%" и заканчивается символом преобразования (буквой, опреде-

ляющей тип преобразования). Между "%" и символом преобразования могут находиться:

Знак минус, который вызывает выравнивание преобразованного аргумента по левому краю поля.

Строка цифр, задающая минимальную ширину поля. Преобразованное число будет напечатано в поле по крайней мере этой ширины, а если необходимо, то и в более широком. Если преобразованный аргумент имеет меньше символов, чем указанная ширина поля, то он будет дополнен слева (или справа, если было указано выравнивание по левому краю) заполняющими символами до этой ширины. Заполняющим символом обычно является пробел, а если ширина поля указывается с лидирующим нулем, то этим символом будет нуль (лидирующий нуль в данном случае не означает восьмеричной ширины поля).

Точка, которая отделяет ширину поля от следующей строки цифр.

Строка цифр (точность); указывает максимальное число символов строки, которые должны быть напечатаны, или число печатаемых справа от десятичной точки цифр для переменных типа float или double.

Модификатор длины l, который указывает, что соответствующий элемент данных имеет тип long, а не int.

Осуществляющая ввод функция scanf является аналогом printf и позволяет проводить в обратном направлении многие

из тех же самых преобразований. Функция scanf(control, arg1, arg2, ...) читает символы из стандартного ввода, интерпретирует их в соответствии с форматом, указанном в аргументе control, и помещает результаты в остальные аргументы. Управляющая строка описывается ниже; другие аргументы, каждый из которых должен быть указателем, определяют, куда следует поместить соответствующим образом преобразованный ввод.

Управляющая строка обычно содержит спецификации преобразования, которые используются для непосредственной интерп-

ретации входных последовательностей. Управляющая строка может содержать:

Пробелы, табуляции или символы новой строки ("символы пустых промежутков"), которые игнорируются;

Обычные символы (не %), которые предполагаются совпадающими со следующими отличными от "символов пустых промежутков" символами входного потока;

Спецификации преобразования, состоящие из символа %, необязательного символа подавления присваивания *, необязательного числа, задающего максимальную ширину поля и символа преобразования.

48.Строкой называется последовательность символов,с которой обращаются как с одним элементом.Строка может содержать буквы,цифры,различные спец.символы.В СИ строковые литералы,или строки-константы заключаются в двойные кавычки.

Строка в СИ является массивом символов,который заканчивается нулвым символом (‘\0’).Доступ к строке осуществляется через указатель,ссылающийся на первый символ строки.Значением строки является адрес ее первого символа.Таким образом,в СИ правомерно сказать, что строка-это указатель,фактически указатель на первый символ строки.Строка может быть привоена в обьявлении либо массиву символов, либо переменной типа char*.

Структуры.

В современных языках программирования существует особый тип данных, который мо-

жет включать в себя несколько элементов более простых (причем разных!) типов.

Структура – это тип данных, который может включать в себя несколько полей - элементов

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

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

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

char title; // название, символьная строка

int year; // год издания, целое число

int pages; // количество страниц, целое число

Для обращения ко всей структуре используется ее имя, а для обращения к отдельному по-

лю имя этого поля ставится через точку. Элементы структуры вводятся последовательно по

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

и с переменной соответствующего типа: числовые переменные могут участвовать в арифмети-

ческих выражениях, со строками можно выполнять все стандартные операции.

strcpy (b.author, " А.С. Пушкин ");

Структуры служат для обработки большого объема информации, поэтому чаще всего в

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

рительно (выше) надо объявить саму структуру как новый тип данных.

Для обращения к полю структуры также используют точку, но теперь надо указать в квад-

ратных скобках еще номер нужной структуры, например

for (i = 0; i < 20; i ++) // цикл по всем структурам в массива

puts(A[i].title); // вывести название книги

Структуры, так же, как и любые другие типы, могут быть параметрами функций и проце-

Работа с файлами.

Файлы бывают текстовые (в которых можно записывать только буквы, цифры, скобки и

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

Текстовые файлы

(так же, как и для линейных массивов) ошибки отсутствия или недостатка данных в файле.

Двоичные файлы

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

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

Описание функций работы с файломи находятся в библиотеке stdio.h

Сначала надо создать указатель на переменную типа FILE (FILE* file;).

Открытие файла производится вызовом функции fopen (file = fopen(file_name, "w");)

Первый параметр этой функции - имя файла, второй - указывает в каком режиме должен быть открыт файл. "w" - открыть для записи, "r" - открыть для чтения, "a" - дополнение файла(это наиболее используемые режимы, хотя есть и другие). Запись и считывание данных из файла осуществляется следующими функциями: fputc, fputs, fgetc, fgets, fprintf, fscanf(описание этих функций смотрите в stdio.h).

Закрытие файла осуществляется вызовом функции fclose (fclose(file);).

Ввод-вывод

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

Финкции вывода:

Int putchar(int c).Выводит один символ в поток стандартного ввода stdout

Int fputs(int c,FILE *f).Выводит один символ в файл f

Int puts(char *s).Выводит строку s до завершающего символа с кодом 0 в поток стандартного вывода.В конце выводится перевод строки

Int fputs(char *s,FILE *f).Выводит строку s до завершающего символа с кодом в файл f.

Int printf().Выводит текст,формат которого описан,в поток стандартного вывода.

Описание формата начинается с символа %

%d-целое число со знаком

%u- целое число без знака

%f-вещественное число

%с-символ

Финкции ввода:

Int getchar(void).читает один символ из потока стандартного вывода stdin

Int fgetc(FILE *f).Читает один символ из файла f

Char *fgets(char *s,int size,FILE *f).Читает из файла f строку размером не более чем size символо,включая символ конца строки и помещает ее по адресу s

Int scanf()Читает из стандартного потока ввода данные в соответствии с заданным форматом

24 Типы данных языка Си.

В Си имеются типы целых чисел различных размеров, со знаком и без, чисел с плавающей запятой, символов, перечисляемых типов (enum) и записей-структур (struct). Кроме того, язык Си предлагает тип объединение (union), с помощью которого можно либо хранить в одном месте памяти разнородные данные, не пересекающиеся по времени существования (это позволяет экономить память), либо обращаться к содержимому участка памяти, как к данным разных типов (что позволяет менять тип-интерпретацию данных, не меняя сами данные).

В Си существует несколько базовых типов:

char - единичный байт, может содержать один символ из допустимого символьного набора;

int - целое, обычно отображающее естественное представление целых в машине;

float - число с плавающей точкой одинарной точности;

double - число с плавающей точкой двойной точности.

Имеется также несколько квалификаторов, которые можно использовать вместе с указанными базовыми типами. Например, квалификаторы short (короткий) и long (длинный) применяются к целым:

long int counter;

В таких объявлениях слово int можно опускать, что обычно и делается.

Квалификаторы signed (со знаком) или unsigned (без знака) можно применять к типу char и любому целочисленному типу. Значения unsigned всегда положительны или равны нулю и подчиняются законам арифметики по модулю 2n, где n - количество битов в представлении типа. Так, если значению char отводится 8 битов, то unsigned char имеет значения в диапазоне от 0 до 255, a signed char - от -128 до 127 (в машине с двоич-

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

Тип long double предназначен для арифметики с плавающей точкой повышенной точности. Как и в случае целых, размеры объектов с плавающей точкой зависят от реализации; float, double и long double могут

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

Арифметические константы.

Целая константа, например 1234, имеет тип int. Константа типа long завершается буквой l или L, например 123456789L; слишком большое целое, которое невозможно представить как int, будет представлено как long.

Беззнаковые константы заканчиваются буквой u или U, а окончание ul или UL говорит о том, что тип константы - unsigned long. Константы с плавающей точкой имеют десятичную точку (123.4), или экспоненциальную часть (1е-2), или же и то и другое. Если у них нет окончания, считается, что они принадлежат к типу double. Окончание f или F указывает на тип float, а 1 или L - на тип long double.

Целое значение помимо десятичного может иметь восьмеричное или шестнадцатеричное представление. Если константа начинается с нуля, то она представлена в восьмеричном виде, если с 0х или с 0Х, то - в шестнадцатеричном. Например, десятичное целое 31 можно записать как 037 или как 0X1F. Записи восьмеричной и шестнадцатеричной констант могут завершаться буквой L (для указания на тип long) и U (если нужно показать, что константа беззнаковая). Например, константа 0XFUL имеет значение 15 и тип unsigned long.

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

Символьная константа есть целое, записанное в виде символа, обрамленного одиночными кавычками, например "х" . Значением символьной константы является числовой код символа из набора символов на данной машине. Например, символьная константа "0" в кодировке ASCII имеет значение 48, которое никакого отношения к числовому значению 0 не имеет. Когда мы пишем "0" , а не какое-то значение (например 48), зависящее от способа кодировки, мы делаем программу независимой от частного значения кода, к тому же она и легче читается. Символьные константы могут участвовать в операциях над числами точно так же, как и любые другие целые, хотя чаще они используются для сравнения с другими символами.

Некоторые символы в символьных и строковых константах записываются с помощью эскейп-последовательностей, например \n (символ новой строки); такие последовательности изображаются двумя символами, но обозначают один.

Кроме того, произвольный восьмеричный код можно задать в виде "\ооо", где ооо - одна, две или три восьмеричные цифры (0...7) или "\xhh", где hh - одна, две или более шестнадцатеричные цифры (0...9, а...f , А...F). Таким образом, мы могли бы написать

#define VTAB "013" /* вертикальная табуляция в ASCII */

#define BELL "\007" /* звонок В ASCII */

или в шестнадцатеричном виде:

#define VTAB "\xb" /* вертикальная табуляция в ASCII */

#define BELL "\x7" /* звонок в ASCII */

Полный набор эскейп-последовательностей таков:

\а сигнал-звонок

\\ обратная наклонная черта

\b возврат на шаг (забой)

\f перевод страницы

\n новая строка

\r возврат каретки

\t горизонтальная табуляция \v вертикальная-табуляция

\? знак вопроса

\" одиночная кавычка

\” двойная кавычка

\ooo восьмеричный код

\xhh шестнадцатеричный код

Символьная константа "\0" - это символ с нулевым значением, так называемый символ null. Вместо просто 0 часто используют запись "\0", чтобы подчеркнуть символьную природу выражения, хотя и в том и другом случае запись обозначает нуль.

Строковая константа, или строковый литерал, - это нуль или более символов, заключенных в двойные кавычки, как, например, "Я строковая константа" или “” (пустая строка).

Кавычки не входят в строку, а служат только ее ограничителями. Так же, как и в символьные константы, в строки можно включать эскейп-последовательности; \", например, представляет собой двойную кавычку. Строковые константы можно конкатенировать ("склеивать") во время компиляции; например, запись двух строк "Здравствуй," " мир!" эквивалентна записи одной следующей строки: "Здравствуй, мир!".

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

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

Константа - это ограниченная последовательность символов алфавита языка, представляющая собой изображение фиксированного (неизменяемого) объекта.

Константы бывают числовые, символьные и строковые. Числовые константы делятся на целочисленные и вещественные.

Целочисленные константы

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

Двоичная система представления данных непосредственно в языке Си не поддерживается. Однако можно воспользоваться файлом binary.h , в котором определены двоичные константы в пределах байта.

Пример использования двоичной системы счисления в языке Си:

1
2
3
4
5
6
7
8
9

#include
#include "binary.h"
int main()
{
unsigned char p = b10001001 | b00001010; // p=b10001011=139
printf("p = %dd = %xh" , p, p);
getchar(); getchar();
return 0;
}

Результат выполнения

В зависимости от значения целой константы компилятор присваивает ей тот или иной тип (char , int , long int ).

С помощью суффикса U (или u ) можно представить целую константу в виде беззнакового целого.

Например, Константе 200U выделяется 1 байт, и старший бит используется для представления одного из разрядов кода числа и диапазон значений становится от 0 до 255 . Суффикс L (или l ) позволяет выделить целой константе 8 байт (long int ).

Совместное использование в любом порядке суффиксов U (или u ) и L (или l ) позволяет приписать целой константе тип unsigned long int , и она займет в памяти 64 разряда, причем знаковый разряд будет использоваться для представления разряда кода (а не знака).

Вещественные константы

Константа с плавающей точкой (вещественная константа) всегда представляется числом с плавающей точкой двойной точности, т. е. как имеющая тип double , и состоит из следующих частей:

• целой части - последовательности цифр;
• точки — разделителя целой и дробной части;
• дробной части - последовательности цифр;
• символа экспоненты е или E ;
• экспоненты в виде целой константы (может быть со знаком).

Любая часть (но не обе сразу) из нижеследующих пар может быть опущена:

• целая или дробная часть;
• точка или символ е (Е ) и экспонента в виде целой константы.

Примеры вещественных констант

• 3.14159
• 2.1Е5
• .123ЕЗ
• 4037е-5

По умолчанию компилятор присваивает вещественному числу тип double . Если программиста не устраивает тип, который компилятор приписывает константе, то тип можно явно указать в записи константы с помощью следующих суффиксов:

• F (или f ) - float для простых вещественных констант,
• L (или l ) - long double для вещественных констант двойной расширенной точности.

Примеры:

• 3.14159F - константа типа float , занимающая 4 байта;
• 3.14L - константа типа long double , занимающая 10 байт.

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

Символьная константа - это один символ, например: ‘z’ . В качестве символьных констант также могут использоваться управляющие коды, не имеющие графического представления. При этом код управляющего символа начинается с символа ‘\’ (обратный слеш).

Как правило, нажатие клавиши Enter генерирует сразу два управляющих символа — перевод строки (0x0A ) и возврат каретки (0x0D ).

Все символьные константы имеют тип char и занимают в памяти 1 байт. Значением символьной константы является числовое значение её внутреннего кода.

Строковые константы

Строковая константа - это последовательность символов, заключенная в кавычки, например:

«Это строковая константа»

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

В конце каждой строковой константы компилятор помещает ‘\0’ (нуль-символ), чтобы программе было возможно определить конец строки. Такое представление означает, что размер строковой константы не ограничен каким-либо пределом, но для определения длины строковой константы её нужно полностью просмотреть.

Поскольку строковая константа состоит из символов, то она имеет тип char . Количество ячеек памяти, необходимое для хранения строковой константы на 1 больше количества символов в ней (1 байт используется для хранения нуль-символа).

Символьная константа ‘x’ и строка из одного символа «x» — не одно и то же. Символьная константа — это символ, используемый для числового представления буквы x, а строковая константа «x» содержит символ ‘x’ и нуль-символ ‘\0’ и занимает в памяти 2 байта. Если в программе строковые константы записаны одна за другой через разделители, то при выполнении программы они будут размещаться в последовательных ячейках памяти.

Целые Константы


Константы с Плавающей Точкой


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


Строки


Ноль


Const


Перечисления

C++ дает возможность записи значений основных типов: символьных констант, целых констант и констант с плавающей точкой. Кроме того, ноль (0) может использоваться как константа любого указательного типа, и символьные строки являются константами типа char. Можно также задавать символические константы. Символическая константа - это имя, значение которого не может быть изменено в его области видимости. В C++ имеется три вида символических констант:

любому значению любого типа можно дать имя и использовать его как константу, добавив к его описанию ключевое слово const;


множество целых констант может быть определено как перечисление;


любое имя вектора или функции является константой.

Целые Константы

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

их десятичные эквиваленты - это 0, 2, 63, 83. В шестнадцатиричной записи эти константы выглядят так:

0x0

0x2

0x3f

0x53

Б уквы a, b, c, d, e и f, или их эквиваленты в верхнем регистре, используются для представления чисел 10, 11. 12, 13, 14 и 15, соответственно. Восьмеричная и шестнадцатиричная записи наиболее полезны для записи набора битов; применение этих записей для выражения обычных чисел может привести к неожиданностям. Например, на машине, где int представляется как двоичное дополнительное шестнадцатеричное целое, 0xffff является отрицательным десятичным числом -1; если бы для представления целого использовалось большее число битов, то оно было бы числом 65535.

Константы с Плавающей Точкой

К онстанты с плавающей точкой имеют тип double. Как и в предыдущем случае, компилятор должен предупреждать о константах с плавающей точкой, которые слишком велики, чтобы их можно было представить. Вот некоторые константы с плавающей точкой:

1.23 .23 0.23 1. 1.0 1.2e10 1.23e-15

З аметьте, что в середине константы с плавающей точкой не может встречаться пробел. Например, 65.43 e-21 является не константой с плавающей точкой, а четырьмя отдельными лексическими символами (лексемами):

65.43 e - 21

и вызовет синтаксическую ошибку.
Е сли вы хотите иметь константу с плавающей точкой типа float, вы можете определить ее так:

Const float pi = 3.14159265;

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

Х отя в C++ и нет отдельного символьного типа данных, точнее, символ может храниться в целом типе, в нем для символов имеется специальная и удобная запись. Символьная константа - это символ, заключенный в одинарные кавычки; например, "a" или "0". Такие символьные константы в действительности являются символическими константами для целого значения символов в наборе символов той машины, на которой будет выполняться программа (который не обязательно совпадает с набором символов, применяемом на том компьютере, где программа компилируется). Поэтому, если вы выполняетесь на машине, использующей набор символов ASCII, то значением "0" будет 48, но если ваша машина использует EBCDIC, то оно будет 240. Употребление символьных констант вместо десятичной записи делает программу более переносимой. Несколько символов также имеют стандартные имена, в которых обратная косая \\ используется как escape-символ:

В опреки их внешнему виду каждое является одним символом. Можно также представлять символ одно-, дву- или трехзначным восьмеричным числом (символ \\, за которым идут восьмеричные цифры), или одно-, дву- или трехзначным шестнадцатиричным числом (\\x, за которым идут шестнадцатиричные цифры). Например:

"\\6" "\\x6" 6 ASCII ack
"\\60" "\\x30" 48 ASCII "0"
"\\137" "\\x05f" 95 ASCII "_"

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

Строки

С троковая константа - это последовательность символов, заключенная в двойные кавычки:

"это строка"

К аждая строковая константа содержит на один символ больше, чем кажется; все они заканчиваются пустым символом "\\0" со значением 0.

Например:

Sizeof("asdf")==5;

С трока имеет тип "вектор из соответствующего числа символов", поэтому "asdf" имеет тип char. Пустая строка записывается "" (и имеет тип char). Заметьте, что для каждой строки s strlen(s)==sizeof(s)-1, поскольку strlen() не учитывает завершающий 0.
Соглашение о представлении неграфических символов с обратной косой можно использовать также и внутри строки. Это дает возможность представлять в строке двойные кавычки и escape-символ \\. Самым обычным символом этого рода является, безусловно, символ новой строки "\\n".

Например:

Cout << "гудок в конце сообщения\\007\\n"

Где 7 - значение ASKII символа bel (звонок).

В строке невозможно иметь "настоящую" новую строку:

"это не строка,
а синтаксическая ошибка"

О днако в строке может стоять обратная косая, сразу после которой идет новая строка; и то, и другое будет проигнорировано.

Например:

Cout << "здесь все \\
ok"

Напечатает

Здесь все ok

Н овая строка, перед которой идет escape (обратная косая), не приводит к появлению в строке новой строки, это просто договоренность о записи.

В строке можно иметь пустой символ, но большинство программ не будет предполагать, что есть символы после него. Например, строка "asdf\\000hjkl" будет рассматриваться стандартными функциями, вроде strcpy() и strlen(), как "asdf".

В ставляя численную константу в строку с помощью восьмеричной или шестнадцатиричной записи благоразумно всегда использовать число из трех цифр. Читать запись достаточно трудно и без необходимости беспокоиться о том, является ли символ после константы цифрой или нет. Разберите эти примеры:

Char v1 = "a\\x0fah\\0129"; // "a" "\\xfa" "h" "\\12" "9"
char v2 = "a\\xfah\\129"; // "a" "\\xfa" "h" "\\12" "9"
char v3 = "a\\xfad\\127"; // "a" "\\xfad" "\\127"

И мейте в виду, что двузначной шестнадцатиричной записи на машинах с 9-битовым байтом будет недостаточно.

Ноль

Н оль (0) можно употреблять как константу любого целого, плавающего или указательного типа. Никакой объект не размещается по адресу 0. Тип нуля определяется контекстом. Обычно (но не обязательно) он представляется набором битов все-нули соответствующей длины.

Const

К лючевое слово const может добавляться к описанию объекта, чтобы сделать этот объект константой, а не переменной.

Например:

Const int model = 145;
const int v = { 1, 2, 3, 4 };

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

Model = 145; // ошибка
model++; // ошибка

З аметьте, что const изменяет тип, то есть ограничивает способ использования объекта, вместо того, чтобы задавать способ размещения константы. Поэтому например вполне разумно, а иногда и полезно, описывать функцию как возвращающую const:

Const char* peek(int i)
{
return private[i];
}

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

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

И спользование указателя вовлекает два объекта: сам указатель и указываемый объект. Снабжение описания указателя "префиксом" const делает объект, но не сам указатель, константой.

Например:

Const char* pc = "asdf"; // указатель на константу
pc = "a"; // ошибка
pc = "ghjk"; // ok

Ч тобы описать сам указатель, а не указываемый объект, как константный, используется операция const*.

Например:

Char *const cp = "asdf"; // константный указатель
cp = "a"; // ok
cp = "ghjk"; // ошибка

Ч тобы сделать константами оба объекта, их оба нужно описать const.

Например:

Const char *const cpc = "asdf"; // const указатель на const
cpc = "a"; // ошибка
cpc = "ghjk"; // ошибка

О бъект, являющийся константой при доступе к нему через один указатель, может быть переменной, когда доступ осуществляется другими путями. Это в частности полезно для параметров функции. Посредством описания параметра указателя как const функции запрещается изменять объект, на который он указывает.

Например:

Char* strcpy(char* p, const char* q); // не может изменить q

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

Например:

Int a = 1;
const c = 2;
const* p1 = &c; // ok
const* p2 = &a; // ok
int* p3 = &c; // ошибка
*p3 = 7; // меняет значение c

К ак обычно, если тип в описании опущен, то он предполагается int.

Перечисления

Е сть другой метод определения целых констант, который иногда более удобен, чем применение const.

Например:

Enum { ASM, AUTO, BREAK };

Определяет три целых константы, называемы перечислителями, и присваивает им значения. Поскольку значения перечислителей по умолчанию присваиваются начиная с 0 в порядке возрастания, это эквивалентно записи:

Const ASM = 0;
const AUTO = 1;
const BREAK = 2;

П еречисление может быть именованным.

Например:

Enum keyword { ASM, AUTO, BREAK };

И мя перечисления становится синонимом int, а не новым типом. Описание переменной keyword, а не просто int, может дать как программисту, так и компилятору подсказку о том, что использование преднамеренное.

Например:

Keyword key;
switch (key) {
case ASM:
// что-то делает
break;
case BREAK:
// что-то делает
break;
}

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

М ожно также задавать значения перечислителей явно.

Например:

Enum int16 {
sign=0100000, // знак
most_significant=040000, // самый значимый
least_significant=1 // наименее значимый
};

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