Программа на языке С++ может содержать следующие символы:
Из символов алфавита формируют ключевые слова и идентификаторы. Ключевые слова — это зарезервированные слова, которые имеют специальное значение для компилятора и используются только в том смысле, в котором они определены (операторы языка, типы данных и т.п.). Идентификатор — это имя программного объекта, представляющее собой совокупность букв, цифр и символа подчёркивания. Первый символ идентификатора — буква или знак подчёркивания, но не цифра. Идентификатор не может содержать пробел. Прописные и строчные буквы в именах различаются, например, ABC, abc, Abc — три различных имени. Каждое имя (идентификатор) должно быть уникальным в пределах функции и не совпадать с ключевыми словами.
В тексте программы можно использовать комментарии. Если текст начинается с двух символов "косая черта" // и заканчивается символом перехода на новую строку или заключён между символами /* и */, то компилятор его игнорирует.
/* Комментарий может выглядеть так! */ //А если вы используете такой способ, //то каждая строка должна начинаться //с двух символов "косая черта".
Комментарии удобно использовать как для пояснений к программе, так и для временного исключения фрагментов программы при отладке.
Для решения задачи в любой программе выполняется обработка каких-либо данных. Данные хранятся в памяти компьютера и могут быть самых различных типов: целыми и вещественными числами, символами, строками, массивами. Типы данных определяют способ хранения чисел или символов в памяти компьютера. Они задают размер ячейки, в которую будет записано то или иное значение, определяя тем самым его максимальную величину или точность задания. Участок памяти (ячейка), в котором хранится значение определённого типа, называется переменной. У переменной есть имя (идентификатор) и значение. Имя служит для обращения к области памяти, в которой хранится значение. Во время выполнения программы значение переменной можно изменить. Перед использованием любая переменная должна быть описана. Оператор описания переменных в языке С++ имеет вид:
тип имя_переменной;
или
тип список_переменных;
Типы данных языка С++ можно разделить на основные и составные.
К основным типам данных языка относят:
char — символьный;int— целый;float— с плавающей точкой;double — двойной точности;bool — логический.Для формирования других типов данных используют основные типы и так называемые спецификаторы. Типы данных, созданные на базе стандартных типов с использованием спецификаторов, называют составными типами данных. В С++ определены четыре спецификатора типов данных:
short — короткий;long — длинный;signed — знаковый;unsigned — беззнаковый.Далее будут рассмотрены назначение и описание каждого типа.
Данные типа char в памяти компьютера занимают один
| Тип | Диапазон | Размер |
|---|---|---|
char |
–128... 127 | 1 байт |
unsigned char |
0... 255 | 1 байт |
signed char |
–128... 127 | 1 байт |
Пример описания символьных переменных:
char c, str; //Описаны две символьные переменные.
При работе с символьными данными нужно помнить, что если в выражении встречается одиночный символ, он должен быть заключён в одинарные кавычки.
Например, 'a', 'b', '+', '3'.
Последовательность символов, то есть строка, при использовании в выражениях заключается в двойные кавычки: "Hello!".
Переменная типа int в памяти компьютера может занимать два, четыре или восемь байтов. Это зависит от разрядности процессора.
Диапазоны значений целого типа представлены в таблице 2.2. По умолчанию все целые типы считаются знаковыми, т.е. спецификатор signed можно не указывать.
| Тип | Диапазон | Размер |
|---|---|---|
int |
–2147483647...2147483647 | 4 байта |
unsigned int |
0...4294967295 | 4 байта |
signed int |
–2147483647...2147483647 | 4 байта |
short int |
–32767...32767 | 2 байта |
long int |
–2147483647...2147483647 | 4 байта |
unsigned short int |
0...65535 | 2 байта |
signed short int |
–32767...32767 | 2 байта |
long long int |
–(263–1)...(263–1) | 8 байт |
signed long int |
–2147483647...2147483647 | 4 байта |
unsigned long int |
0...4294967295 | 4 байта |
unsigned long long int |
0...264–1 | 8 байт |
Пример описания целочисленных данных:
int a, b, c; unsigned long int A, B, C;
Внутреннее представление вещественного числа в памяти компьютера отличается от представления целого числа. Число с плавающей точкой представлено в экспоненциальной форме $$mE \pm p$$, где $$m$$ — мантисса (целое или дробное число с десятичной точкой), $$p$$ — порядок (целое число). Для того чтобы перевести число в экспоненциальной форме к обычному представлению с фиксированной точкой, необходимо мантиссу умножить на десять в степени порядок. Например,
$$-6.42E + 2 = -6.42 · 10^2 = -642,\\ 3.2E - 6 = 3.2 · 10^{-6} = 0.0000032$$Обычно величины типа float занимают 4 байта, из которых один двоичный разряд отводится под знак, 8 разрядов под порядок и 23 под мантиссу. Поскольку старшая цифра мантиссы всегда равна 1, она не хранится.
Величины типа double занимают 8 байт, в них под порядок и мантиссу отводится 11 и 52 разряда соответственно. Длина мантиссы определяет точность числа, а длина порядка его диапазон. Спецификатор типа long перед именем типа double указывает, что под величину отводится 10 байт.
Диапазоны значений вещественного типа представлены в табл. 2.3.
| Тип | Диапазон | Размер |
|---|---|---|
float |
3.4Е-38...3.4E+38 | 4 байта |
double |
1.7Е-308...1.7E+308 | 8 байт |
long double |
3.4Е-4932...3.4E+4932 | 10 байт |
Пример описания вещественных переменных:
double x1, x2, x3; float X, Y, Z;
Переменная типа bool может принимать только два значения true (истина) или false (ложь). Любое значение не равное нулю интерпретируется как true, а при преобразовании к целому типу принимает значение равное 1. Значение false представлено в памяти как 0.
Пример описания данных логического типа:
bool F, T;
Множество значений этого типа пусто. Он используется для определения функций, которые не возвращают значения, для указания пустого списка аргументов функции, как базовый тип для указателей и в операции приведения типов.
Константы это величины, которые не изменяют своего значения в процессе выполнения программы. Оператор описания константы имеет вид:
сonst тип имя_константы = значение;
Константы в языке С++ могут быть целыми, вещественными, символьными или строковыми. Обычно компилятор определяет тип константы по внешнему виду, но существует возможность и явного указания типа, например,
const double pi=3.141592653589793;
Кроме того, константа может быть определена с помощью #define. Эта директива служит для замены часто использующихся констант, ключевых слов, операторов или выражений некоторыми идентификаторами. Идентификаторы, заменяющие текстовые или числовые константы, называют именованными константами. Основная форма синтаксиса директивы следующая:
#define идентификатор текст
Например,
#define PI 3.141592653589793 int main( ) ...
Структурированный тип данных характеризуется множественностью образующих его элементов. В C++ это массивы, строки, структуры и файлы.
Массив — совокупность данных одного и того же
В общем виде массив можно описать так:
тип имя [размерность_1][размерность_2]...[размерность_N];
Например,
float x [10]; //Описан массив из 10 вещественных чисел. int a[3][4]; //Описан двумерный целочисленный массив, матрица из 3-х строк и 4-х столбцов. double b[2][3][2]; //Описан трехмерный массив.
Для доступа к элементу массива достаточно указать его порядковый номер, а если массив многомерный (например, таблица), то несколько номеров:
имя_массива[номер_1][номер_2]...[номер_N]
Например:
x[5], a[2][3], b[1][2][2] .
Элементы массива в С++ нумеруются с нуля. Первый элемент, всегда имеет номер ноль, а номер последнего элемента на единицу меньше заданной при его описании размерности:
char C[5]; //Описан массив из 5 символов, нумерация от 0 до 4.
char. Например:
char s[25]; //Описана строка из 25 символов.
Например
struct fraction //Объявлена структура правильная дробь.
{
//Определяем поля структуры:
int num; //поле числитель,
int den; //поле знаменатель.
}
...
fraction d, D [20]; //Определена переменная d, массив D[20], типа fraction.
...
d.num; //Обращение к полю num переменной d.
D[4].den; //Обращение к полю den пятого элемента массива D.
Указатели широко применяются в С++. Можно сказать, что именно наличие указателей сделало этот язык удобным для программирования. С другой стороны это одна из наиболее сложных для освоения возможностей С++. Идея работы с указателями состоит в том, что пользователь работает с адресом ячейки памяти.
Как правило, при обработке оператора объявления переменной
тип имя_переменной;
компилятор автоматически выделяет память под переменную имя_переменной в соответствии с указанным типом:
char C; //Выделена память под символьную переменную C
Доступ к объявленной переменной осуществляется по её имени. При этом все обращения к переменной заменяются на адрес ячейки памяти, в которой хранится её значение. При завершении программы или функции, в которой была описана переменная, память автоматически освобождается.
Доступ к значению переменной можно получить иным способом — определить собственные переменные для хранения адресов памяти. Такие переменные называют указателями. С помощью указателей можно обрабатывать массивы, строки и структуры, создавать новые переменные в процессе выполнения программы, передавать адреса фактических параметров функциям и адреса функций в качестве параметров.
Итак, указатель это переменная, значением которой является адрес памяти, по которому хранится объект определённого типа (другая переменная). Например, если С это переменная типа char, а Р — указатель на С, значит в Р находится адрес по которому в памяти компьютера хранится значение переменной С.
Как и любая переменная, указатель должен быть объявлен. При объявлении указателей всегда указывается тип объекта, который будет храниться по данному адресу:
тип *имя_переменной;
Например:
int *p; //По адресу, записанному в переменной p, будет храниться переменная типа int
Звёздочка в описании указателя, относится непосредственно к имени, поэтому чтобы объявить несколько указателей, её ставят перед именем каждого из них:
float *x, y, *z; //Описаны указатели на вещественные числа x и z (сами вещественные //значения — *x, *z), а так же вещественная переменная y, её адрес — y.
Выражение задаёт порядок выполнения действий над данными и состоит из операндов (констант, переменных, обращений к функциям), круглых скобок и знаков операций. Операции делятся на унарные (например, -с) и бинарные (например, а+b). В таблице 2.4 представлены основные операции языка С++.
| Операция | Описание |
|---|---|
| Унарные операции | |
++ |
увеличение значения на единицу |
-- |
уменьшение значения на единицу |
~ |
поразрядное отрицание |
! |
логическое отрицание |
- |
арифметическое отрицание (унарный минус) |
+ |
унарный плюс |
|
получение адреса |
* |
обращение по адресу |
(type) |
преобразование типа |
| Бинарные операции | |
+ |
сложение |
- |
вычитание |
* |
умножение |
/ |
деление |
% |
остаток от деления |
<< |
сдвиг влево |
>> |
сдвиг вправо |
< |
меньше |
> |
больше |
<= |
меньше или равно |
>= |
больше или равно |
== |
равно |
!= |
не равно |
|
поразрядная конъюнкция (И) |
^ |
поразрядное исключающее ИЛИ |
| |
поразрядная дизъюнкция (ИЛИ) |
|
логическое И |
|| |
логическое ИЛИ |
= |
присваивание |
*= |
умножение с присваиванием |
/= |
деление с присваиванием |
+= |
сложение с присваиванием |
-= |
вычитание с присваиванием |
%= |
остаток от деления с присваиванием |
<<= |
сдвиг влево с присваиванием |
>>= |
сдвиг вправо с присваиванием |
= |
поразрядная конъюнкция с присваиванием |
|= |
поразрядная дизъюнкция с присваиванием |
^= |
поразрядное исключающее ИЛИ с присваиванием |
| Другие операции | |
? |
условная операция |
, |
последовательное вычисление |
sizeof |
определение размера |
(тип) |
преобразование типа |
Перейдём к подробному рассмотрению основных операций языка.
Обычная операция присваивания имеет вид:
имя_переменной=значение;
где значение это выражение, переменная, константа или функция. Выполняется операция так. Сначала вычисляется значение выражения указанного в правой части оператора, а затем его результат записывается в область памяти, имя которой указано слева.
Например,
b=3; //Переменной b присваивается значение, равное трём. a=b; //Переменной а присваивается значение b. c=a+2*b; //Переменной c присваивается значение выражения. c=c +1; //Значение переменой с увеличивается на единицу. a=a *3; //Значение переменой а увеличивается в три раза.
Задача 2.1. Пусть в переменной а хранится значение, равное 3, а в переменную b записали число 5. Поменять местами значения переменных а и b.
Для решения задачи понадобится дополнительная переменная c(см. рис. 2.1). В ней временно сохраняется значение переменной а. Затем, значение переменной bзаписывается в переменную a, а значение переменной c в переменную b.
c=a; //Шаг 1. с=3 a=b; //Шаг 2. a=5 b=c; //Шаг 3. b=3
(рис 2.1) Использование буферной переменной
Если в операторе присваивания левая и правая часть это переменные разных типов, то происходит преобразование: значение переменной в правой части преобразуется к типу переменной в левой части. Следует учитывать, что при этом можно потерять информацию или получить другое значение.
В С++ существует возможность присваивания нескольким переменным одного и того же значения. Такая операция называется множественным присваиванием и в общем виде может быть записана так:
имя_1 = имя_2 = ... = имя_N = значение;
Запись a=b=c=3.14159/6; означает, что переменным a, b и c было присвоено одно и то же значение 3.14159/6.
Операции + =, -=, *=, / = называют составным присваиванием. В таких операциях при вычислении выражения стоящего справа используется значение переменной из левой части, например так:
x+=p; //Увеличение x на p, то же что и x=x+p. x-=p; //Уменьшения x на p, то же что и x=x-p. x*=p; //Умножение x на p, то же что и x=x*p. x/=p; //Деление x на p, то же что и x=x/p.
Операции +, -, *, / относят к арифметическим операциям. Их назначение понятно и не требует дополнительных пояснений. При программировании арифметических выражений следует придерживаться простых правил. Соблюдать очерёдность выполнения арифметических операций. Сначала выполняются операции умножения и деления (1-й уровень), а затем сложения и вычитания (2-й уровень). Операции одного уровня выполняются последовательно друг за другом. Для изменения очерёдности выполнения операций используют скобки. Таблица 2.5 содержит примеры записи алгебраических выражений.
| Математическая запись | Запись на языке С++ |
|---|---|
| $$2\cdot a+b\cdot(c+d)$$ | 2*a+b*(c+d) |
| $$3\cdot\frac{a+b}{c+d}$$ | 3*(a+b)/(c+d) |
| $$\frac{3\cdot a-2\cdot b}{c\cdot d}$$ | (3*a-2*b)/(c*d) или (3*a-2*b)/c/d |
| $$\frac{(b-a)^2}{c+\frac{1}{d-2}}-\frac{a^2+1}{b^2+cd}$$ | (b-a)*(b-a)/(c+1/(d-2))-(a*a+1)/(b*b+c*d) |
Операции инкремента ++ и декремента -- так же причисляют к арифметическим, так как они выполняют увеличение и уменьшение на единицу значения переменной. Эти операции имеют две формы записи: префиксную (операция записывается перед операндом) и постфиксную (операция записывается после операнда). Так, например оператор p=p+1; можно представить в префиксной форме ++p; и в постфиксной p++;.Эти формы отличаются при использовании их в выражении. Если знак декремента (инкремента) предшествует операнду, то сначала выполняется увеличение (уменьшение) значения операнда, а затем операнд участвует в выражении. Например,
x=12; y=++x; //В переменных x и y будет храниться значение 13.
Если знак декремента (инкремента) следует после операнда, то сначала операнд участвует в выражении, а затем выполняется увеличение (уменьшение) значения операнда:
x=12; y=x++; //Результат — число 12 в переменной y, а в x — 13.
Остановимся на операциях целочисленной арифметики.
Операция целочисленного деления / возвращает целую часть частного (дробная часть отбрасывается) в том случае, если она применяется к целочисленным операндам, в противном случае выполняется обычное деление: 11/4 = 2 или 11.0/4 = 2.75.
Операция остаток от деления % применяется только к целочисленным операндам: 11%4 = 3.
К операциям битовой арифметики относятся следующие операции: , |, ^, ~, <<, >>. В операциях битовой арифметики действия происходят над двоичным представлением целых чисел.
Арифметическое И (). Оба операнда переводятся в двоичную систему, затем над ними происходит логическое поразрядное умножение операндов по следующим правилам:
11=1, 10=0, 01=0, 00=0.
Например, если А=14 и В=24, то их двоичное представление — А=0000000000001110 и В=0000000000011000. В результате логического умножения A и B получим 0000000000001000 или 8 в десятичной системе счисления (рис. 2.2). Таким образом, AB=1424=8.
(рис 2.2) Пример логического умножения
(рис 2.3) Пример логического сложения
Арифметическое ИЛИ (|). Здесь также оба операнда переводятся в двоичную систему, после чего над ними происходит логическое поразрядное сложение операндов по следующим правилам:
1|1=1, 1|0=1, 0|1=1, 0|0=0.
Например, результат логического сложения чисел А=14 и В=24 будет равен A |B=30 (рис. 2.3).
Арифметическое исключающее ИЛИ (^). Оба операнда переводятся в двоичную систему, после чего над ними происходит логическая поразрядная операция ^ по следующим правилам:
1^1=0, 1^0=1, 0^1=1, 0^0=0.
Арифметическое отрицание (~). Эта операция выполняется над одним операндом. Применение операции ~ вызывает побитную инверсию двоичного представления числа (рис. 2.4).
(рис 2.4) Пример арифметического отрицания
Сдвиг влево (M<<L). Число M, представленное в двоичной системе, сдвигается влево на Lпозиций. Рассмотрим операцию 15 << 3. Число 15 в двоичной системе имеет вид 1111. При сдвиге его на 3 позиции влево получим 1111000. В десятичной системе это двоичное число равно 120. Итак, 15 << 3 =120(рис. 2.5). Заметим, что сдвиг на один разряд влево соответствует умножению на два, на два разряда — умножению на четыре, на три — умножению на восемь. Таким образом, операция M << Lэквивалентна умножению числа M на 2 в степени L.
(рис 2.5) Пример операции "Сдвиг влево"
(рис 2.6) Пример операции "Сдвиг вправо"
Сдвиг вправо (M>>L). Число M, представленное в двоичной системе, сдвигается вправо на L позиций, что эквивалентно целочисленному делению числа M на 2 в степени L. Например, 15 >> 1=7 (рис. 2.6), 15 >> 3=1.
В С++ определены следующие логические операции || (или), (и), ! (не). Логические операции выполняются над логическими значениями true (истина) и false (ложь). В языке С ложь — 0, истина — любое значение $$\ne$$0. В таблице 2.6 приведены результаты логических операций.
| A | B | !A | AB | A||B |
|---|---|---|---|---|
| 0 | 0 | 1 | 0 | 0 |
| 0 | 1 | 1 | 0 | 1 |
| 1 | 0 | 0 | 0 | 1 |
| 1 | 1 | 0 | 1 | 1 |
Операции отношения возвращают в качестве результата логическое значение. Таких операций шесть: >, >=, <, <=, ==, !=. Результат операции отношения — логическое значение true (истина) или false (ложь).
Для организации разветвлений в простейшем случае можно использовать условную операцию ? :. Эта операция имеет три операнда и в общем виде может быть представлена так:
условие ? выражение1 : выражение2;
Работает операция следующим образом. Если условие истинно (не равно 0), то результатом будет выражение1, в противном случае выражение2. Например, операция y=x<0 ? -x : x; записывает в переменную y модуль числа х.
Для приведения выражения к другому типу данных в С++ существует операция преобразования типа:
(тип) выражение;
Например, в результате действий x=5; y=x/2; z=(float) x/2; переменная y примет значение равное 2 (результат целочисленного деления), а переменная z = 2.5.
Вычислить размер объекта или типа в байтах можно с помощью операции определения размера, которая имеет две формы записи:
sizeof (тип); или sizeof выражение;
Например, предположим, что была описана целочисленная переменная int k=3;.Исходя из того, что тип int занимает в памяти 4 байта, в переменную m=sizeof k; будет записано число 4.
В результате работы команд double z=123.456; p=sizeof (k+z); значение переменной p стало равно 8, т. к. вещественный тип double более длинный (8 байтов) по сравнению с типом int(4 байта) и значение результата было преобразовано к более длинному типу. В записи операции sizeof (k+z) были использованы скобки. Это связано с тем, что операция определения типа имеет более высокий приоритет, чем операция сложения. При заданном значении z=123.456; та же команда, но без скобок p=sizeof k+z; вычислит p=4+123.456=127.456.
Команда s = sizeof "Hello"; определит, что под заданную строку в памяти было выделено s=6 байтов, т. к. объект состоит из 5 символов и один байт на символ окончания строки.
При работе с указателями часто используют операции получения адреса и разадресации * (табл. 2.7).
| Описание | Адрес | Значение, хранящееся по адресу |
|---|---|---|
| тип *p | p | *p |
| тип p | p | p |
Операция получения адреса возвращает адрес своего операнда. Например:
float a; //Объявлена вещественная переменная а float *adr_a; //Объявлен указатель на тип float adr_a=a; //Оператор записывает в переменную adr_a адрес переменной a
Операция разадресации * возвращает значение переменной, хранящееся по заданному адресу, т.е. выполняет действие, обратное операции :
float a; //Объявлена вещественная переменная а. float *adr_a; //Объявлен указатель на тип float. a=*adr_a; //Оператор записывает в переменную a вещественное значение, //хранящееся по адресу adr_a.
К указателям применяют операцию присваивания. Это значит, что значение одного указателя можно присвоить другому. Если указатели одного типа, то для этого применяют обычную операцию присваивания:
//Описана вещественная переменная и два указателя. float PI =3.14159,*p1, *p2; //В указатели p1 и p2 записывается адрес переменной PI. p1=p2=PI;
Если указатели ссылаются на различные типы, то при присваивании значения одного указателя другому, необходимо использовать преобразование типов. Без преобразования можно присваивать любому указателю указатель void*.
Рассмотрим пример работы с указателями различных типов:
float PI = 3.14159; //Объявлена вещественная переменная. float *p1; //Объявлен указатель на float. double *p2; //Объявлен указатель на double. p1=PI; //Переменной p1 присваивается значение адреса PI. p2=(double *) p1; //Указателю на double присваивается значение, //которое ссылается на тип float.
В указателях p1 и p2 хранится один и тот же адрес (p1=0012FF7C), но значения, на которые они ссылаются, разные (*p1=3.14159, *p2=2.642140e-308). Это связано с тем, указатель типа *float адресует 4 байта, а указатель *double — 8 байт. После присваивания p2=(double *)p1; при обращении к *p2 происходит следующее: к переменной, хранящейся по адресу p1, дописывается ещё следующих 4 байта из памяти. В результате значение *p2 не совпадает со значением *p1.
Таким образом, при преобразовании указателей разного типа приведение типов разрешает только синтаксическую проблему присваивания. Следует помнить, что операция * над указателями различного типа, ссылающимися на один и тот же адрес, возвращает различные значения.
Над адресами С++ определены следующие арифметические операции:
Сложение и вычитание указателей с константой n означает, что указатель перемещается по ячейкам памяти на столько байт, сколько занимает n переменных того типа, на который он указывает. Например, пусть указатель имеет символьный тип, и его значение равно 100. Результат сложения этого указателя с единицей — 101, так как для хранения переменной типа char требуется один байт. Если же значение указателя равно 100, но он имеет целочисленный тип, то результат его сложения с единицей будет составлять 104, так как для переменной типа int отводится четыре байта.
Эти операции применимы только к указателям одного типа и имеют смысл в основном при работе со структурными типами данных, например массивами.
Фактически получается, что значение указателя изменяется на величину sizeof(тип).Если указатель на определённый тип увеличивается или уменьшается на константу, то его значение изменяется на величину этой константы, умноженную на размер объекта данного типа. Например:
//Объявление массива из 10 элементов.
double mas [10] = { 1.29,3.23,7.98,5.54,8.32,2.48,7.1 };
double *p1; //Объявление указателя на double
p1=mas [ 0 ]; //Присвоение указателю адреса нулевого элемента массива.
p1=p1+3; //Увеличение значения адреса на 3*8=24 (размер типа double), в результате указатель
//сместится на три ячейки, размером double каждая.
Вычитание двух указателей определяет, сколько переменных данного типа размещается между указанными ячейками. Разность двух указателей это разность их значений, делённая на размер типа в байтах. Так разность указателей на третий и нулевой элементы массива равна трём, а на третий и девятый — шести. Суммирование двух указателей не допускается.
Операции инкремента и декремента, соответственно, увеличивают или уменьшают значение адреса:
double *p1; float *p2; int *i; p1++; //Увеличение значения адреса на 8. p2++; //Увеличение значения адреса на 4. i ++; //Увеличение значения адреса на 4.
К указателям так же применимы операции отношения ==, !=, <, >, <=, >=. Иными словами, указатели можно сравнивать. Например, если $$i$$ указывает на пятый элемент массива, а $$j$$ на первый, то отношение $$i > j$$ истинно. Кроме того, любой указатель всегда можно сравнить на равенство с константой нулевого указателя
В C++ определены стандартные функции над арифметическими
| Обозначение | Действие |
|---|---|
abs(x) |
Модуль целого числа $$x$$ |
fabs(x) |
Модуль вещественного числа $$x$$ |
sin(x) |
Синус числа $$x$$ |
cos(x) |
Косинус числа $$x$$ |
tan(x) |
Тангенс числа $$x$$ |
atan(x) |
Арктангенс числа $$x,x\in(-\frac{\pi}{2};\frac{\pi}{2})$$ |
acos(x) |
Арккосинус числа $$x$$ |
asin(x) |
Арксинус числа $$x$$ |
exp(x) |
Экспонента, $$e^x$$ |
log(x) |
Натуральный логарифм, $$(x > 0)$$ |
log10(x) |
Десятичный логарифм, $$(x > 0)$$ |
sqrt(x) |
Корень квадратный, $$(x > 0)$$ |
pow(x,y) |
Возведение числа $$x$$ в степень $$y$$ |
ceil(x) |
Округление числа $$x$$ до ближайшего большего целого |
floor(x) |
Округление числа $$x$$ до ближайшего меньшего целого |
Примеры записи математических выражений с использованием встроенных функций представлены в табл. 2.9.
| Математическая запись | Запись на языке С++ |
|---|---|
| $$\sqrt[3]{(a+b)^2}$$ | pow((a+b) *(a+b),1./3) или pow(pow(a+b,2),1./3) |
| $$\cos^4(x)$$ | pow(cos(x), 4) |
| $$e^{2x}$$ | exp(2*x) |
| $$e^{5\sin(\frac{x}{2})}$$ | exp(5*sin(x/2)) |
| $$\sin^2(\sqrt{x})$$ | pow(sin(sqrt(x)),2) |
| $$\ln(|x-2|)$$ | log(fabs(x -2)) |
| $$\log_b a$$ | log(a)/log(b) |
| $$\frac{\lg(x^2+1)}{\lg(4)}$$ | log10(x*x+1)/log10(4) |
| $$\sin(x^2+y^2)+\cos\frac{(x^2+y^2)}{2\cdot y}+\sqrt{x^2+y^2}$$ | z=x*x+y*y; sin(z)+cos(z/(2*y))+sqrt(z); |
Определённую проблему представляет применение функции pow(x,y).При программировании выражений, содержащих возведение в степень, надо внимательно проанализировать значения, которые могут принимать $$x$$ и $$y$$, так как в некоторых случаях возведение $$x$$ в степень $$y$$ невыполнимо.
Так, ошибка возникает, если $$x$$ — отрицательное число, а $$y$$ — дробь. Предположим, что$$ y$$ — правильная дробь вида $$\frac{k}{m}$$. Если знаменатель $$m$$ чётный, это означает вычисление корня чётной степени из отрицательного числа, а значит, операция не может быть выполнена. В противном случае, если знаменатель m нечётный, можно воспользоваться выражением z = –pow(fabs(x),y). Например, вычисление кубического корня из вещественного числа можно представить командой:
z=(x<0)? -pow(fabs(x),(double)1/3): pow(x,(double)1/3);
Программа на языке С++ состоит из функций, описаний и директив препроцессора.
Одна из функций должна обязательно носить имя main. Элементарное описание функции имеет вид:
тип_результата имя_функции (параметры)
{
оператор1;
оператор2;
...
операторN;
}
Здесь, тип_результата — это тип того значения, которое функция должна вычислить (если функция не должна возвращать значение, указывается тип void), имя_функции — имя, с которым можно обращаться к этой функции, параметры — список аргументов функции (может отсутствовать), оператор1, оператор2,..., операторN — операторы, представляющие тело функции, они обязательно заключаются в фигурные скобки и каждый оператор заканчивается точкой с запятой. Как правило, программа на С++ состоит из одной или нескольких, не вложенных друг в друга, функций.
Основному тексту программы предшествуют директивы препроцессора, предназначенные для подключения библиотек, которые в общем виде выглядят так:
#include <имя_библиотеки>
Каждая такая строка даёт компилятору команду присоединить программный код, который хранится в отдельном файле с расширением .h. Такие файлы называют файлами заголовков. С их помощью можно выполнять ввод-вывод данных, работать с математическими функциями, преобразовывать данные, распределять память и многое другое. Например, описание стандартных математических функций находится в заголовочном файле math.h.
Общую структуру программы на языке С++ можно записать следующим образом:
директивы препроцессора
описание глобальных переменных
тип_результата имя1(параметры1)
{
описание переменных функции имя1;
операторы1;
}
тип_результата имя2(параметры2)
{
описание переменных функции имя2;
операторы2;
}
............................... .
тип_результата имяN(параметрыN)
{
описание переменных функции имяN;
операторыN;
}
тип_результата main(параметры)
{
описание переменных главной функции;
операторы главной функции;
}
По месту объявления переменные в языке Си можно разделить на три класса: локальные, глобальные и формальные параметры функции.
Локальные переменные объявляются внутри функции и доступны только в ней. Например:
int f1 ( )
{
//В функции f1 описана другая переменная s,
int s;
s =6; //ей присвоено значение 6 .
}
int f2 ( )
{
//В функции f2 определена ещё одна переменная s,
long int s;
s =25; //ей присвоено значение 25.
}
int main ( )
{
//В функции main определена вещественная переменная s,
float s;
s =4.5; //и ей присвоено значение 4.5.
}
Глобальные переменные описываются до всех функций и доступны из любого места программы. Например:
float s; //Определена глобальная переменная s .
int f1 ( )
{
//В функции f1 переменной s присваивается значение 6 .
s =6;
}
int f2 ( )
{
//В функции f2 переменной s присваивается значение 2.1.
s =2.1;
}
int main ( )
{
//В главной функции переменной s присваивается значение 4.5 .
s =4.5;
}
Формальные параметры функций описываются в списке параметров функции. Работа с функциями подробно описана в главе 4.
Ввод-вывод данных в языке С++ осуществляется либо с помощью функций ввода-вывода в стиле С, либо с использованием библиотеки классов С++. Преимущество объектов С++ в том, что они легче в использовании, особенно если ввод-вывод достаточно простой. Функции ввода-вывода, унаследованные от С — громоздкие, но более гибко управляют форматированным выводом данных.
Функция
printf(строка форматов, список выводимых переменных);
выполняет форматированный вывод переменных, указанных в списке, в соответствии со строкой форматов.
Функция
scanf(строка форматов, список адресов вводимых переменных);
выполняет ввод переменных, адреса которых указанны в списке, в соответствии со строкой форматов.
Строка форматов содержит символы, которые будут выводиться на экран или запрашиваться с клавиатуры, и так называемые спецификации. Спецификации это строки, которые начинаются символом % и выполняют управление форматированием:
% флаг ширина.точность модификатор тип
Параметры флаг, ширина, точность и модификатор в спецификациях могут отсутствовать. Значения параметров спецификаций приведены в табл. 2.10.
| Параметр | Назначение |
|---|---|
| Флаги | |
- |
Выравнивание числа влево. Правая сторона дополняется пробелами. По умолчанию выравнивание вправо. |
+ |
Перед числом выводится знак "+" или "-" |
Пробел |
Перед положительным числом выводится пробел, перед отрицательным "–" |
# |
Выводится код системы счисления: 0 — перед восьмеричным числом, 0х (0Х) перед шестнадцатеричным числом. |
| Ширина | |
n |
Ширина поля вывода. Если n позиций недостаточно, то поле вывода расширяется до минимально необходимого. Незаполненные позиции заполняются пробелами. |
On |
То же, что и n, но незаполненные позиции заполняются нулями. |
| Точность | |
ничего |
Точность по умолчанию |
n |
Для типов e, E, f выводить n знаков после десятичной точки |
| Модификатор | |
h |
Для d, i, o, u, x, X тип short int. |
l |
Для d, i, o, u, x, X тип long int. |
| Тип | |
c |
Символьный тип char. |
d |
Десятичное int со знаком. |
i |
Десятичное int со знаком. |
o |
Восьмеричное int unsigned. |
u |
Десятичное int unsigned. |
x,X |
Шестнадцатеричное int unsigned, при х используются символы a-f, при Х — A - F. |
f |
Значение со знаком вида [-]dddd.dddd. |
e |
Значение со знаком вида [-]d.dddde[+|-]ddd. |
E |
Значение со знаком вида [-]d.ddddE[+|-]ddd. |
g |
Значение со знаком типа e или fв зависимости от значения и точности. |
G |
Значение со знаком типа E или f в зависимости от значения и точности. |
s |
Строка символов. |
Кроме того, строка форматов может содержать некоторые специальные символы, которые приведены в табл. 2.11.
| Символ | Назначение |
|---|---|
\b |
Сдвиг текущей позиции влево. |
\n |
Перевод строки. |
\r |
Перевод в начало строки, не переходя на новую строку |
\t |
Горизонтальная табуляция. |
\' |
Символ одинарной кавычки. |
\" |
Символ двойной кавычки. |
\? |
Символ ? |
Первой строкой программы, в которой будут применяться функции вводавывода языка С, должна быть директива #include <stdio.h>. Заголовочный файл stdio.h содержит описание функций ввода-вывода.
Рассмотрим работу функций на примере следующей задачи.
Задача 2.2. Зная a, b, c — длины сторон треугольника, вычислить площадь S и периметр P этого треугольника.
Входные данные: a, b, c. Выходные данные: S, P.
Для вычисления площади применим формулу Герона: $$S=\sqrt{r\cdot(r-a)\cdot(r-b)\cdot(r-c)}$$, где $$r=\frac{a+b+c}{2}$$ — полупериметр.
Далее приведены две программы для решения данной задачи и результаты их работы (рис. 2.7,рис. 2.8).
//ЗАДАЧА 2.2 Вариант первый
#include <iostream>
#include <stdio.h>
#include <math.h>
using namespace std;
int main ( )
{
float a, b, c, S, r; //Описание переменных.
printf ( " a = " ); //Вывод на экран символов a=.
//В функции scanf для вычисления адреса переменной применяется операция .
scanf ( " % f ",a ); //Запись в переменную а значения введённого с клавиатуры .
printf ( " b = " ); //Вывод на экран символов b=.
scanf ( " % f ",b ); //Запись в переменную b значения введённого с клавиатуры.
printf ( " c = " ); //Вывод на экран символов c=
scanf ( " % f ",c ); //Запись в переменную c значения введённого с клавиатуры.
r=(a+b+c ) / 2; //Вычисление полупериметра.
S=sqrt ( r * ( r -a ) *( r -b )*( r -c ) ); //Вычисление площади треугольника.
printf ( " S =%5.2 f \ t ", S ); //Вывод символов S=, значения S и символа табуляции \t.
//Спецификация %5.2f означает, что будет выведено вещественное
//число из пяти знаков, два из которых после точки.
printf ( " p =%5.2 f \ n ",2 *r ); //Вывод символов p=, значения выражения 2*r
//и символа окончания строки.
//Оператор printf("S=%5.2f \t p=%5.2f \n",S,2*r) выдаст тот же результат.
return 0;
}
(рис 2.7) Результаты работы программы к задаче 2.2 (вариант 1)
//ЗАДАЧА 2.2. Вариант второй
#include <iostream>
#include <stdio.h>
#include <math.h>
using namespace std;
int main ( )
{
float a, b, c, S, r;
printf ( " Vvedite a, b, c \ n " ); //Вывод на экран строки символов.
scanf ( " % f % f % f ",a,b, c ); //Ввод значений.
r=(a+b+c ) / 2;
S=sqrt ( r * ( r-a ) * ( r-b ) * ( r -c ) );
printf ( " S =%5.2 f \ t p =%5.2 f \ n ",S, 2 * r ); //Вывод результатов.
return 0;
}
(рис 2.8) Результаты работы программы к задаче 2.2 (вариант 2)
Описание объектов для управления вводом-выводом содержится в заголовочном файле iostream. При подключении этого файла с помощью директивы #include <iostream> в программе автоматически создаются объекты-cin для ввода с клавиатуры и cout для вывода на экран, а также операции помещения в поток << и чтения из потока >>.
Итак, с помощью объекта cin и операции >> можно ввести значение любой переменной. Например, если переменная i описана как целочисленная, то команда cin>> i; означает, что в переменную i будет записано некое целое число, введённое с клавиатуры. Если нужно ввести несколько переменных, следует написать cin>>x>>y>>z; .
Объект cout и операция << позволяют вывести на экран значение любой переменной или текст. Текст необходимо заключать в двойные кавычки, кроме того, допустимо применение специальных символов \t и \n (табл. 2.11). Запись cout<<i; означает вывод на экран значения переменной i. А команда cout<<x<<"\t"<<y;выведет на экран значения переменных xи y, разделённые символом табуляции.
Задача 2.3. Дано трехзначное число. Записать его цифры в обратном порядке и вывести на экран новое число.
Разберём решение данной задачи на конкретном примере. Здесь будут использоваться операции целочисленной арифметики.
Пусть P=456. Вычисление остатка от деления числа P на 10 даст его последнюю цифру (количество единиц в числе P): 456 % 10 =6.
Операция деления нацело числа P на 10 позволит уменьшить количество разрядов и число станет двузначным:
456 / 10 = 45.
Остаток от деления полученного числа на 10 будет следующей цифрой числа P (количество десятков в числе P):
45 % 10 = 5.
Последнюю цифру числа P (количество сотен) можно найти так:
456 / 100 = 4.
Так как в задаче требовалось записать цифры числа P в обратном порядке, значит в новом числе будет 6 сотен, 5 десятков и 4 единицы:
S = 6*100 + 5*10 + 4 = 654.
Далее приведён текст программы, реализующей данную задачу для любого трехзначного числа.
#include <iostream>
using namespace std;
int main ( int argc, char *argv [ ] )
{
unsigned int P, S; //Определение целочисленных переменных без знака .
cout<<" P = "; //Вывод на экран символов P=.
cin >>P; //Ввод заданного числа P.
S=P%10*100+P/10%10*10+P/ 100; //Вычисление нового числа S .
cout<<" S = "<<S<<endl; //Вывод на экран символов S= и значения переменной S .
return 0;
}
Задача 2.4. Пусть целочисленная переменная i и вещественная переменная d вводятся с клавиатуры. Определить размер памяти, отведённой для хранения этих переменных и их суммы, в байтах. Вычислить, сколько памяти будет выделено для хранения строки С Новым Годом!.Вывести на экран размеры различных типов данных языка С++ в байтах.
Далее приведён текст программы.
#include <iostream>
using namespace std;
int main ( )
{
int i; //Определение целочисленной переменной .
double d; //Определение вещественной переменной .
cout<<" i = "; cin >>i; //Ввод переменной i .
cout<<" d = "; cin >>d; //Ввод переменной d .
//Размер памяти, отведённой под переменную i .
cout<<" Размер i : "<< sizeof i <<" \ n ";
//Размер памяти, отведённой под переменную d .
cout<<" Размер d : "<< sizeof d<<" \ n ";
//Размер памяти, отведённой под значение выражения i+d .
cout<<" Размер i + d : "<< sizeof ( i+d )<<" \ n ";
cout<<" Размер строки <С Новым Годом!>: ";
//Размер памяти, отведённой под строку.
cout<<sizeof " С Новым годом! "<<" \ n ";
//Вычисление размеров различных типов данных:
cout<<" Размер char : "<< sizeof ( char )<<" \ n ";
cout<<" Размер int : "<< sizeof ( int )<<" \ n ";
cout<<" Размер short int : "<< sizeof ( short int )<<" \ n ";
cout<<" Размер long int : "<< sizeof ( long int )<<" \ n ";
cout<<" Размер long long int : ";
cout<<sizeof ( long long int )<<" \ n ";
cout<<" Размер float : "<< sizeof ( float )<<" \ n ";
cout<<" Размер double : "<< sizeof ( double )<<" \ n ";
cout<<" Размер long double : "<<sizeof ( long double )<<" \ n ";
return 0;
}
Результаты работы
i= 23 d= 45.76 Размер i: 4 Размер d: 8 Размер i+d: 8 Размер <С Новым годом!>:26 Размер char: 1 Размер int: 4 Размер short int: 2 Размер long int: 4 Размер long long int:8 Размер float: 4 Размер double: 8 Размер long double: 12
Разработать программу на языке С++. Все входные и выходные данные в задачах — вещественные числа. Для ввода и вывода данных использовать функции scanf и printf.
Разработать программу на языке С++. Все входные данные в задачах — целые числа. Для ввода и вывода данных использовать объектно-ориентированные средства ввода-вывода.
Разработать программу на языке С++. Все входные и выходные данные в задачах — вещественные числа. Для ввода и вывода данных использовать функции scanf и printf
Вычислить значение выражения $$y=f(x)$$ при заданном значении x. Варианты заданий представлены в табл. 2.12.
| № | Выражение $$f(x)$$ |
|---|---|
| 1 | $$\sqrt[7]{ x^2 + 2.7 \cdot\pi \cdot \cos \sqrt{|x^3|} - 2 + e^x}$$ |
| 2 | $$\tg^4 x + sin^2 \frac{\pi}{x}- e^{2x^2 +3. 6x- 1}$$ |
| 3 | $$|x^4 - \cos x | -\sqrt[9]{ 1 + \sqrt{x^6}} + \sin^3\frac{\pi}{e^x+1}$$ |
| 4 | $$\log_4 |e^x - 4 | - \sqrt[7]{\frac{2\cdot x}{3.21+\cos^2\frac{\pi}{7}}}$$ |
| 5 | $$\sqrt[3]{\sqrt{|x |}} + | \ctg^2 x +\frac{e^x}{ 2\cdot \pi} - x^3 |$$ |
| 6 | $$x^5 + \log_3^2(3x^2 + 5) + \sqrt[9]{ (\pi - 6x^2)^2}$$ |
| 7 | $$\frac{1 - \log |x - cos(2x- \pi)|}{6 + x^{4x- 1}} + \sqrt[5]{ x^3}$$ |
| 8 | $$e^{x+ \frac{\pi}{3}} + \sqrt[3]{\tg\frac{x^5}{x^2+13.22}} + \cos^3 x$$ |
| 9 | $$x^{1+\frac{3\cdot\pi}{4}}-3x^3-\sqrt[5]{(x+1)^4+\lg\frac{x}{x+1}}$$ |
| 10 | $$\sqrt[5]{x^3+\cos\sqrt{|x^3|}}+\frac{e^x}{\cos(3\cdot x +\frac{\pi}{15}}$$ |
| 11 | $$e^{2x}+\sqrt[5]{\ctg\frac{(x-\pi)^9}{x^4+3.4}}+\sin^26.2x$$ |
| 12 | $$\sqrt[5]{(x+\tg\alpha)^2}-\frac{1-\ln|e^x+\cos\frac{\pi}{8}|}{2}$$ |
| 13 | $$\log(e^x+27)-\sqrt{x^3+\frac{\sqrt[5]{x^7}+14}{\sin 5x+5.1\cdot\pi}}$$ |
| 14 | $$\ln|\cos(x-2\cdot\pi)|-\sqrt[3]{1+\frac{e^x}{\sin x-3}}$$ |
| 15 | $$\sqrt{x^3+\frac{\sqrt[3]{x^4}-1}{\sin x+\pi+e^x}}$$ |
| 16 | $$\sqrt[3]{\frac{1+3\cdot\pi}{1+x^2}}+|\arctg^2 x^3|$$ |
| 17 | $$\tg^2|x|+3^{2x^2-e^x}+\frac{\sqrt[7]{x^2}}{\cos^2\pi x}$$ |
| 18 | $$x^4-\sqrt[5]{\pi-\sqrt{|x^3|}+\sin^2\frac{x}{x^2+1}}$$ |
| 19 | $$\log(e^x+6)-\sqrt[3]{(x-4)^2+1.47\sin\sqrt{|\pi\cdotx|}}$$ |
| 20 | $$\frac{x^5}{\sin|x-7|}+\log^2(x^2+2.5)-\sqrt[3]{(\pi-6.1x^2)^2}$$ |
| 21 | $$\ctg^2\frac{x\cdot\pi}{3}-\sqrt{|x|}-3.4^{x^2-10}+\ln(x^2+3)$$ |
| 22 | $$\log_5|x^3-e^x|-\sqrt[3]{\frac{2x}{\cos(x+1.23\cdot\pi)}}$$ |
| 23 | $$|\cos\frac{\pi}{7}-e^x|-\sqrt[7]{2+\sqrt{x^5}}+\ln\frac{x^4+1}{6}$$ |
| 24 | $$\log(x^2+2)-\sin^2x+\sqrt[5]{2-\sqrt{|x|}}+\sin\frac{\pi}{e^x+1}$$ |
| 25 | $$\log_2e^x-\cos\frac{x}{\pi}+\sqrt[3]{\frac{|\tg(2x)|}{2.6+x^2+x^3}}$$ |
Для получения официальных документов о завершении программы дополнительного профессионального образования (удостоверения о повышении квалификации, дипломов о профессиональной переподготовке и MBA) необходимо предоставить:
Внимание! Вы можете не заказывать доставку бумажной версии официального документы, а скачать его в электронном виде и распечатать самостоятельно. Информация о выданном документе в течение 1 месяца загружается в Федеральную информационную систему «Федеральный реестр сведений о документах об образовании и (или) о квалификации, документах об обучении» - ФИС ФРДО.
Доступ на новый сайт осуществляется с использованием адреса электронной почты, который был указан вами при регистрации на "старом". Мы постарались перенести все ваши данные с прежнего ресурса, однако не исключена вероятность потери части информации.
При возникновении проблемы со входом, воспользуйтесь функцией сброса пароля
Если вы обнаружите несоответствия, пожалуйста, сообщите нам.