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

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

<тип>[<модификаторы>]<имя> [<нач_знач.>];

int i,j,k;

float t,r,s;

double g=0.5;

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

Имя не должно совпадать с ключевыми словами.

12. Понятие «тип» в С++; категории: скалярные и агрегированные типы; основные (фундаментальные) и производные типы.

1.Все типы можно разбить на 4 категории:

1) «пустой» - void;

2) Скалярный (основной/ элементарный/ стандартный):

a) арифметические типы,

b)перечисленные,

c) указатели,

d)ссылочный (в С++);

3) Тип «функция»;

4) Агрегированный:

a) массивы,

b)структуры,

c) объединения,

d)классы (в С++).

2.Еще одна классификация типов:

1) Основные (фундаментальные):

void, char, int, float, double со своими модификаторами

2) Производные:

Указатели (*), ссылки (&), массивы ([]), функции (()), структуры, классы, объединения.

13.Разделители и лексемы в С++.

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

Разделители: пробелы, вертикальная и горизонтальная табуляция, символ начала новой строки «\».

«Borland \

International» // симв. «\» склеит в одну строку

// - кометнарий

/* комментарий */

Лексемы делятся на 6 классов:

1) ключевые слова

2)идентификаторы

3) константы

4) литеральные строки “..”

5) операторы

6)разделители (знаки пунктуации)

14.Опесание оператора в С++. Унарные и бинарные операторы.

Оператор – лексема, которая задаёт действия, когда применяется к переменной или к другому объекту в выражении, за исключением [], (),?: (условие). Многосимвольные операторы рассматриваются как одна лексема: >=, <=.

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

o a*b умножение

*ptr косвенная адресация

o a&b побитовое умножение

&b адресная операция (операция ссылки)

Унарные операторы (применяются к одному операнду):

& - ссылка, взять адресс

* - разъименование (взять содержимое по этому адресу)

+ - унарный плюс

- - унарный минус

~ - побитовое отрицание

! - логическое отрицание

++ - префикс (++i) и постфикс (i++)

-- - префикс (--i) и постфикс (i++)

Бинарные операторы:

1) аддитивные (+, -)

2) мультипликативные (*, /, %)

3) оператор сдвига (<<, >>)

4) побитовые операторы (& -и,¦ - или, ^ - xor)

5) логические (&&, ||)

6) оператор присвоения:

o Простой =

o Комбинированный *=, /=, -=, %=, <<=, >>=, &=, ¦=, ^=

7) оператор эквивалентности (==,!=)

8) оператор выбора компоненты (. –прямой, ‑> ‑косвенний)

9)оператор отношения (<, >, <=, >=)

10)оператор елемента класса

:: - доступ к сфере действия (разширение области видимости)

.* - разименованный указатель

->* - разименованный указатель через непрямой селектор

11)условный оператор А? Х: У
15.Преобразование операндов в арифметических выражениях.

Для бинарных операторов операнды разных типов приводятся к «старшему», то есть более длинному типу.

Типы в порядке убывания:

long double → double → float → unsigned long → long → unsigned int → int → char

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

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

Преобразование char в int, unsigned int, long, unsigned long выполняется размножением нуля, если тип char unsigned, или знака если тип char signed.

Преобразования типа int в long или unsigned long выполняется размножением знака.

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

Преобразование старших целых типов в младшие выполняется отбрасыванием старших байтов.

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

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

- Операции приведения типа (<тип>):

int a=8, b=5, c, d;

float var1, var2;

var1 = a / b; // 1.0

var2 = (float) a/ (float) b; //1.6 –во всех компиляторах

- Оператор запятая

E1, E2

E1 – вычисляется как void выражение, E2 – вычисляется после, определяя тип и результат всего выражения запятой

Е1, Е2, …., Еn – Ei выч-я с лево на право и рез. будет в Еn, во избежание неопределенности надо заключ в круглые скобки при вызове ф-ции:

func(I,(j=1,j+5),k)

Функции преобразования данных ASCII:

atof char -> double atoi char -> int

atol char -> long acvt double -> char

itoa int -> chat ltoa long -> char
16.Сложние объявления и элементы объявления.

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

Объявление состоит из четырёх частей: необязательного спецификатора, базового типа, объявляющей части и, возможно, инициализатора.

<тип> [<мод-ры>] <имя> [<нач_знач>]

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

* указатель

* const константный указатель

& ссылка

[] массив

() функция

Разрешается объявлять несколько имен в одном операторе объявления. Например мы можем объявить две переменных:

int x, y;

Операторы объявления применяются только к ближайшему имени и не относится к соседнем именам в объявления. Например:

int *p, y //int*p; int y;
17.Указатели (2 категории).

Способ доступа к переменной: по имени, через механизм указателей.

Указатель-константа – это значения адреса оперативной памяти, которое изменить нельзя.

Указатель-переменная (=просто указатель) – это переменная для хранения адреса памяти, обычно другой переменной/ объекта.

Описание:

<имя> * <имя_перем.> [=<нач_зн.>];

int * p_int;

long * p1;

float t; float * ptr = &t;

Место выделяемое под переменную типа указатель зависит от модели памяти (мб ук-ль far или near).

int var1, * ptr = (int *) 200;//если не зад-я конст-а

int * ptr2 = & var1;

Операция ссылка & - взять адрес объекта. Операция * - взять из адреса содержимое.

var1=15;

*ptr=*ptr2 + 10; //=25, более гибкое

Равносильно: t = var1 + 10;

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

Для: void * ppp;

Обязательно: (char *) ppp;

Операция разиминования не может применятся к константе так как она не имеет доступного адреса в памяти.

Существуют ограничение на использованье &:

1) нельзя определить адрес константы

//int p1 = & 0xff00; - error

2)нельзя определить адресс значения вычисления как результат арифметического выражения.

Int var1 = 3, * ptr;

// ptr= & (var1 * 5); - error

3)Нельзя получить адрес переменной описанной как register

Unsigned int register r1; & r1;

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

int a, *ptr 1, *ptr2 = & a;

ptr1 = (int *) & ptr2;

Указатель типа void * часто называют родовым (generic), он не отражать информацию о размере объекта в памяти и может использоваться в таком выражении:

unsigned long block = 0xffeeddcc; void * p = & block;

char ch; unsigned <int> two_bytes;

long int four_bytes;

ch=*(char*)p; // ch=0xcc;

two_bytes= *(unsigned*)p; // two_bytes=0xddxx

four_bytes=*(long int *) p; // four_bytes=0xffeeddcc;

Для указателей-переменных допустимы следующие операции:

- присваиванье

- инкремент / декремент

- сложение/ вычитание

- сравнение

Арифметические операции с указателем выполняются по специальным правилам:

type * ptr + [-] N то значение указ-я изменяется на N*sizeof (type) (N - константа)

Разность двух указателей – это разность их значений, делённая на sizeof (type).

Сравнение указателей имеет смысл только когда они относятся к одному и тому же массиву.

Указатель на ф-цию

На этапе работы программы ф-цию можно вызывать или брать адрес.

Переменная с адресом указателем на ф-цию.

Для просто указателя определены математические операции.

float * p;

р+5 – продвижение на 5 эл-ов типа.

Указатели на ф-цию не допускают математических операций:

<тип > (* < ид-р_указ-я>) (<список_типов_парам>);

Если напишем <тип > * (< ид-р_указ-я>).., то смысл – ф-ция, которая возвращает адрес int, т.е. это тип результата

Пример:

void good_msg(char*);

void error_msg(char *);

void (* efct) (char *);

{…

error_msg(“Фаил не найден”);

efct = error_msg; //↔efct=&error_msg;

efct(“Запись не найдена”);

efct = error_msg; //↔efct=&error_msg;

efct(“Обработка файла завершена”);

}

18.Выражения в С++: порядок вычисления, ошибки и переполнение.

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

С++ позволяет перегрузить некоторые стандартные операторы, то есть определить новое поведение оператора при использовании классов в выражении:

сout<<c;

Однако перегрузка не может изменить приоритет оператора.

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

Каждое подвыражение вычисляется слева на право, а все выражение вычисляется в самое правое выражение.

Ошибки и переполнение (выход за диапазон)

Всегда проявляются ошибки деления на 0 и переполнения с плавающей точкой (выход за диапазон отведенной памяти).

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

Поиск по сайту: