Основы программирования Автор Черкес Наталия Борисовна Содержание

Зарегистрируйтесь, чтобы просмотреть полный документ!

Основы программирования Автор Черкес Наталия Борисовна

Содержание 1. 2. 3. 4. 5. 6. Лекция № 1. Заглянем в компьютер Лекция № 2. Введение в язык С++ Лекция № 3. Структура программы. Операции. Выражения Лекция № 4. Операторы Лекция 5. Указатели и массивы Лекция 6. Введение в обработку символов и строк

Заглянем в компьютер

Общая схема компьютера Оперативная память Экран (терминал) Центральный процессор Материнская плата Клавиатура Дисковод «Мышь» Дисковод

Общая структура персонального компьютера Основная память ПЗУ Монитор Манипуляторы Сканер Модем Графопостроитель (плоттер) ОЗУ Системная магистраль (шина) Процессор Дисковод Сетевая Принтер Клавиатура Дисковод для жёстких для гибких для компакт карта дисков (CD-ROM )

Процессор Функции процессора: q обработка данных по заданной программе (выполнение над ними арифметических и логических операций) – функция арифметикологического устройства (АЛУ); q программное управление работой устройств ЭВМ – функция устройства управления (УУ). В состав процессора входят также регистры (процессорная память) – ряд специальных запоминающих ячеек. Регистры выполняют две функции: q кратковременное хранение числа или команды; q выполнение над ними некоторых операций. Важнейшие регистры: q счетчик команд (служит для автоматической выборки команд программы из последовательных ячеек памяти, в нем хранится адрес выполняемой команды); q регистр команд и состояний (служит для хранения кода команды).

Команда – это элементарная операция, которую должна выполнить ЭВМ. Команда содержит: q код выполняемой операции; q адреса операндов; q адрес размещения результата. Одноадресная команда ADD Двухадресная команда X ADD Трёхадресная команда ADD X Y Z X Y

Команда Выполнение команды разбивается на следующие этапы: q из ячейки памяти, адрес которой хранится в счетчике команд, выбирается команда (при этом содержимое счётчика команд увеличивается); q команда передаётся в устройство управления (УУ) (в регистр команд); q устройство управления расшифровывает адресное поле команды; q по сигналам устройства управления операнды выбираются из памяти в АЛУ (в регистры операндов); q УУ расшифровывает код операции и выдаёт сигнал АЛУ выполнить операцию; q результат операции остаётся в процессоре либо возвращается в ОЗУ. Программа ОЗУ Процессор Счетчик команд Регистры операндов Сумматор УУ АЛУ

Данные и программы Слово машинной памяти 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 1 Старший байт 0 0 0 1 Младший байт слово 1 0 0 1 0 1 1205 1 0 0 1 0 1 1197 Буквенные обозначения систем счисления D – десятичная (decimal); B – двоичная (binary); O – восьмеричная (octal); H – шестнадцатеричная (hex)

Данные и программы Ядро ОС Программа Оперативная память Программа Драйвер … Программа … Операционная система Другие программы Незанятая часть ОП Программы в памяти компьютера

Данные и программы Выполняется программа-загрузчик Загружаемая программа в файле Загрузка программы Оперативная память Диск

Типы языков программирования 1. Машинные языки 2. Языки ассемблера 3. Языки высокого уровня

Этапы создания программы 1. Спецификация задачи – точное и однозначное описание задачи; 2. Проектирование программы – описание действий в самом общем виде (спецификация программы); 3. Кодирование или разработка программы; 4. Отладка программы; 5. Тестирование программы; 6. Составление сопровождающих документов

Данные и программы Выполняется текстовый редактор Текст программы на клавиатуре и экране Выполняется транслятор Исходный текст в файле Оперативная память Объектный код в файле Создание исходного файла Диск

Данные и программы Выполняется компановщик Библиотека системы программирования или другие подпрограммы Программа Объектный код Оперативная память Программа Диск Создание выполнимой машинной программы

Данные и программы Выполняется интерпретатор Оперативная память Библиотека системы программирования или другие подпрограммы Входные и выходные данные программы Исходный текст Диск Интерпретация высокоуровневой программы

Системы счисления Кодирование – представление символов одного алфавита символами другого по определённым правилам. Система счисления – способ представления любого числа с помощью алфавита символов, называемых цифрами. Непозиционная система счисления В ней вводится ряд символов для представления основных чисел, а остальные числа – результат их сложения и вычитания. Основные символы для обозначения десятичных разрядов в римской системе счисления: I – один, X – десять, C – сто, M – тысяча и их половины V – пять, L – пятьдесят, D – пятьсот. Натуральные числа записываются при помощи повторения этих цифр (например, II – два, III – три, XXX – тридцать, CC – двести). Если же большая цифра стоит перед меньшей цифрой, то они складываются, если наоборот – вычитаются (например, VII – семь, IX – девять).

Системы счисления Позиционная система счисления В ней любое число представляется в виде последовательности цифр, количественное значение которых зависит от места (позиции), которое занимает каждая из них в числе. Алфавит десятичной системы состоит из десяти символов: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, называемых арабскими цифрами. По правилам этой системы счисления символы располагаются, начиная с нулевой позиции и далее по возрастающей слева направо. Символ 1 в нулевой позиции – это единица, а в первой позиции – это уже 10 единиц. Официальное «рождение» двоичной системы счисления (в её алфавите два символа: 0 и 1) связывают с именем Готфрида Вильгельма Лейбница. В 1703 г. он опубликовал статью, в которой были рассмотрены все правила выполнения арифметических действий над двоичными числами.

Системы счисления Десятичная Двоичная Восьмеричная Шестнадцатеричная 0 00 0 0 1 01 1 1 2 10 2 2 3 11 3 3 4 100 4 4 5 101 5 5 6 110 6 6 7 111 7 7 8 1000 10 8 9 1001 11 9 10 1010 12 А 11 1011 13 B 12 1100 14 C 13 1101 15 D 14 1110 16 E 15 1111 17 F

Системы счисления Основание системы счисления – это количество символов в ее алфавите. Переход из двоичной системы счисления в восьмеричную осуществляется заменой справа налево каждой триады двоичных цифр на одну восьмеричную цифру. 001 111 1 7 001 110 1 6 101 000 5 0 Переход из восьмеричной системы счисления в двоичную осуществляется заменой каждой восьмеричной цифры тремя двоичными. 3 011 4 1 6 100 001 110 2 0 010 000

Системы счисления Для перевода числа из десятичной системы счисления в любую другую систему счисления нужно делить «до упора» это число на основание той системы, в которую переводим число, а потом прочесть остатки от деления справа налево. D 114 8 2 14 6 8 1 D 114 2 0 57 2 1 28 2 0 14 2 0 7 2 1 3 2 1 1 D 114 = O 162 = B 1110010 D 162 16 2 10 D 162 = H A 2

Системы счисления Для перевода числа из любой системы счисления в десятичную систему счисления нужно умножить содержимое каждого разряда на основание той системы, из которой переводим число, в степени, равной порядковому номеру разряда, и все сложить. O 162 = 1 82 +6 81+2 80 = D 114 B 1110010 = 1 26+1 25+1 24+0 23+0 22 +1 21+0 20 = D 114 H A 2 =10 161+2 160 = D 162

Системы счисления Переход из двоичной системы счисления в шестнадцатеричную осуществляется заменой справа налево каждой четверки двоичных цифр на одну шестнадцатеричную цифру. 0001 1111 1 0010 F 2 0110 0101 0000 5 6 0 Переход из шестнадцатеричной системы счисления в двоичную осуществляется заменой каждой шестнадцатеричной цифры четырьмя двоичными. 3 0011 4 0100 1 0001 A 1010 F 0 1111 0000

Введение в язык С++

Состав языка Алфавит языка или его символы – это основные неделимые знаки, с помощью которых пишутся все тексты на языке. Лексема или элементарная конструкция – минимальная единица языка, имеющая самостоятельный смысл. Выражение задает правило вычисления некоторого значения. Оператор задает законченное описание некоторого действия. Операторы Выражения Лексемы Символы Состав алгоритмического языка

Этапы создания исполняемой программы

Алфавит языка Алфавит С++ включает: ü прописные и строчные латинские буквы и знак подчеркивания; ü арабские цифры от 0 до 9; ü специальные знаки: " { } , | [ ] ( ) + - / % *. ? ‘ : < = > ! & # ~ ; ^ ü пробельные символы: пробел, символы табуляции, символы перехода на новую строку. Из символов алфавита формируются лексемы языка: ü идентификаторы; ü ключевые (зарезервированные) слова; ü знаки операций; ü константы; ü разделители (скобки, точка, запятая, пробельные символы). Границы лексем определяются другими лексемами, такими, как разделители или знаки операций.

Идентификаторы Идентификатор – это имя программного объекта. В идентификаторе могут использоваться латинские буквы, цифры и знак подчеркивания. Прописные и строчные буквы различаются. Первым символом идентификатора может быть буква или знак подчеркивания, но не цифра. Пробелы внутри имен не допускаются. Длина идентификатора по стандарту не ограничена, но некоторые компиляторы и компоновщики налагают на нее ограничения. Идентификатор создается на этапе объявления переменной, функции, типа и т. п. , после этого его можно использовать в последующих операторах программы. При выборе идентификатора необходимо иметь в виду следующее: ü идентификатор не должен совпадать с ключевыми словами и именами используемых стандартных объектов языка; ü не рекомендуется начинать идентификаторы с символа подчеркивания, поскольку они могут совпасть с именами системных функций или переменных, и, кроме того, это снижает мобильность программы; ü на идентификаторы, используемые для определения внешних переменных, налагаются ограничения компоновщика (использование различных компоновщиков или версий компоновщика накладывает разные требования на имена внешних переменных).

Ключевые слова asm auto bool break case catch char class const_cast continue default delete do double dynamic_cast else enum explicit export extern false float for friend goto if inline int long mutable namespace new operator private protected public register reinterpret_cast return short signed sizeof static_cast struct switch template this throw true try typedef typeid typename union unsigned using virtual void volatile wchar_t while

Знаки операций Знак операции – это один или более символов, определяющих действие над операндами. Внутри знака операции пробелы не допускаются. Операции делятся на унарные, бинарные и тернарную по количеству участвующих в них операндов. Один и тот же знак может интерпретироваться по-разному в зависимости от контекста. Все знаки операций за исключением [ ], ( ) и ? : представляют собой отдельные лексемы.

Константы Константами называют неизменяемые величины. Различаются целые, вещественные, символьные и строковые константы. Компилятор, выделив константу в качестве лексемы, относит ее к одному из типов по ее внешнему виду. Форматы констант, соответствующие каждому типу, приведены в таблице: Константа Формат Десятичный: последовательность десятичных цифр, начинающаяся не с нуля, если это не число нуль Восьмеричный: нуль, за которым следуют восьмеричные цифры (0, 1, 2, 3, 4, 5, 6, 7) Целая Шестнадцатеричный: Ох или ОХ, за которым следуют шестнадцатеричные цифры (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, А, В, С, D, Е, F) Десятичный: [цифры], [цифры] Вещественная Экспоненциальный: [цифры][. ][цифры]{Е|е}[+|-[цифры] Символьная Один или два символа, заключенных в апострофы Строковая Последовательность символов, заключенная в кавычки Примеры 8, 0, 199226 01, 020, 07155 0 х. А, 0 x 1 В 8, 0 Х 00 FF 5. 7, . 001, 35. 0. 2 Е 6, . 11 е-3, 5 Е 10 'А', ‘ю’, '*', ‘db’ ‘’ ‘n’, ‘12’ 'x 07' "Здесь был Vasia", "t. Значение r= х. F 5"

Константы Символ обратной косой черты используется для представления: ü кодов, не имеющих графического изображения (например, а – звуковой сигнал, n – перевод курсора в начало следующей строки); ü символов апострофа ( ' ), обратной косой черты ( ), знака вопроса (? ) и кавычки ( " ); ü любого символа с помощью его шестнадцатеричного или восьмеричного кода, например, 73, x. F 5. Числовое значение должно находиться в диапазоне от 0 до 255. Последовательности символов, начинающиеся с обратной косой черты, называют управляющими или escapeпоследовательностями.

Константы Управляющие последовательности в языке С++ Изображение а b f n r t v \ ’ " ? ddd xddd Шестнадцатеричный код 7 8 С А D 9 В 5 С 27 22 3 F — ddd Наименование Звуковой сигнал Возврат на шаг Перевод страницы (формата) Перевод строки Возврат каретки Горизонтальная табуляция Вертикальная табуляция Обратная косая черта Апостроф Кавычка Вопросительный знак Восьмеричный код символа Шестнадцатеричный код символа

Комментарии Комментарий либо начинается с двух символов «прямая косая черта» (//) и заканчивается символом перехода на новую строку, либо заключается между символами-скобками /* и */. Внутри комментария можно использовать любые допустимые на данном компьютере символы, а не только символы из алфавита языка С++, поскольку компилятор комментарии игнорирует. Вложенные комментарии-скобки стандартом не допускаются, хотя в некоторых компиляторах разрешены.

Типы данных С++ Концепция типа данных Основная цель любой программы состоит в обработке данных. Данные различного типа хранятся и обрабатываются по-разному. В любом алгоритмическом языке каждая константа, переменная, результат вычисления выражения или функции должны иметь определенный тип. Тип данных определяет: ü внутреннее представление данных в памяти компьютера; ü множество значений, которые могут принимать величины этого типа; ü операции и функции, которые можно применять к величинам этого типа. Все типы языка С++ можно разделить на основные и составные. В языке С++ определено шесть основных типов данных для представления целых, вещественных, символьных и логических величин. На основе этих типов программист может вводить описание составных типов. К ним относятся массивы, перечисления, функции, структуры, ссылки, указатели, объединения и классы.

Типы данных С++ Основные типы данных Основные (стандартные) типы данных часто называют арифметическими, поскольку их можно использовать в арифметических операциях. Для описания основных типов определены следующие ключевые слова: int (целый); char (символьный); wchar_t (расширенный символьный); bool (логический); float (вещественный); double (вещественный с двойной точностью). Первые четыре тина называют целочисленными (целыми), последние два – типами с плавающей точкой. Код, который формирует компилятор для обработки целых величин, отличается от кода для величин с плавающей точкой. Существует четыре спецификатора типа, уточняющих внутреннее представление и диапазон значений стандартных типов: short (короткий); long (длинный); signed (знаковый); unsigned (беззнаковый).

Типы данных С++ Целый тип (int) Размер типа int не определяется стандартом, а зависит от компьютера и компилятора. Для 16 -разрядного процессора под величины этого типа отводится 2 байта, для 32 -разрядного – 4 байта. Спецификатор short перед именем типа указывает компилятору, что под число требуется отвести 2 байта независимо от разрядности процессора. Спецификатор long означает, что целая величина будет занимать 4 байта. Таким образом, на 16 -разрядном компьютере эквиваленты int и short int, а на 32 -разрядном – int и long int. Внутреннее представление величины целого типа – целое число в двоичном коде. При использовании спецификатора signed старший бит числа интерпретируется как знаковый (0 – положительное число, 1 – отрицательное). Спецификатор unsigned позволяет представлять только положительные числа, поскольку старший разряд рассматривается как часть кода числа.

Типы данных С++ Целый тип (int) По умолчанию все целочисленные типы считаются знаковыми, то есть спецификатор signed можно опускать. Константам, встречающимся в программе, приписывается тот или иной тип в соответствии с их видом. Если этот тип по каким-либо причинам не устраивает программиста, он может явно указать требуемый тип с помощью суффиксов L, l (long) и U, u (unsigned). Например, константа 32 L будет иметь тип long и занимать 4 байта. Можно использовать суффиксы L и U одновременно, например, 0 x 22 UL или 05 Lu. Типы short int, long int, signed int и unsigned int можно сокращать до short, long, signed.

Типы данных С++ Символьный тип (char) Под величину символьного типа отводится количество байт, достаточное для размещения любого символа из набора символов для данного компьютера, что и обусловило название типа. Как правило, это 1 байт. Тип char, как и другие целые типы, может быть со знаком или без знака. В величинах со знаком можно хранить значения в диапазоне от -128 до 127. При использовании спецификатора unsigned значения могут находиться в пределах от 0 до 255. Этого достаточно для хранения любого символа из 256 -символьного набора ASCII. Величины типа char применяются также для хранения целых чисел, не превышающих границы указанных диапазонов. Расширенный символьный тип (wchar_t) Тип wchar_t предназначен для работы с набором символов, для кодировки которых недостаточно 1 байта, например, Unicode. Размер этого типа зависит от реализации; как правило, он соответствует типу short. Строковые константы типа wchar_t записываются с префиксом L, например, L"Gates".

Типы данных С++ Логический тип (bool) Величины логического типа могут принимать только значения true и false, являющиеся зарезервированными словами. Внутренняя форма представления значения false – 0 (нуль). Любое другое значение интерпретируется как true. При преобразовании к целому типу true имеет значение 1.

Типы данных С++ Типы с плавающей точкой (float, double и long double) Стандарт С++ определяет три типа данных для хранения вещественных значений: float, double и long double. Типы данных с плавающей точкой хранятся в памяти компьютера иначе, чем целочисленные. Внутреннее представление вещественного числа состоит из двух частей – мантиссы и порядка. В IBM PC-совместимых компьютерах величины типа float занимают 4 байта, из которых один двоичный разряд отводится под знак мантиссы, 8 разрядов под порядок и 23 под мантиссу. Мантисса – это число, большее 1. 0, но меньшее 2. 0. Поскольку старшая цифра мантиссы всегда равна 1, она не хранится. Для величин типа double, занимающих 8 байт, под порядок и мантиссу отводится 11 и 52 разряда соответственно. Длина мантиссы определяет точность числа, а длина порядка – его диапазон. Спецификатор long перед именем типа double указывает, что под величину отводится 10 байт. Константы с плавающей точкой имеют по умолчанию тип double. Можно явно указать тип константы с помощью суффиксов F, f (float) и L, 1 (long). Например, константа 2 E+6 L будет иметь тип long double, а константа 1. 82 f – тип float.

Типы данных С++ Диапазоны значений простых типов данных для IBM PC Тип Диапазон значений Размер (байт) 1 bool true и false 1 signed char -128. . . 127 1 unsigned char 0. . . 255 2 signed short int -32 768. . . 32 767 2 unsigned short int 0. . . 65 535 4 signed long int -2 147 483 648. . . 2 147 483 647 4 unsigned long int 0. . . 4 294 967 295 4 float 3. 4 e-38. . . 3. 4 e+38 8 double 1. 7 e-308. . . 1. 7 е+308 long double 3. 4 e-4932. . . 3. 4 e+4932 10

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

Переменные Переменная – это именованная область памяти, в которой хранятся данные определенного типа. У переменной есть имя и значение. Имя служит для обращения к области памяти, в которой хранится значение. Во время выполнения программы значение переменной можно изменять. Перед использованием любая переменная должна быть описана. Пример описания целой переменной с именем а и вещественной переменной х: int a; float х; Общий вид оператора описания переменных: [класс памяти] [const] тип имя [инициализатор];

Переменные [класс памяти] [const] тип имя [инициализатор]; Рассмотрим правила задания составных частей этого оператора. Необязательный класс памяти может принимать одно из значений auto, extern, static и register. Модификатор const показывает, что значение переменной изменять нельзя. Такую переменную называют именованной константой, или просто константой. При описании можно присвоить переменной начальное значение, это называется инициализацией. Инициализатор можно записывать в двух формах – со знаком равенства: = значение или в круглых скобках: ( значение ) Константа должна быть инициализирована при объявлении. В одном операторе можно описать несколько переменных одного тина, разделяя их запятыми.

Переменные Примеры: short int а = 1; const char С = ‘С’; char s, sf = 'f'; // целая переменная а // символьная константа С //инициализация относится // только к sf char t (54); float с = 0. 22, x(3), sum;

Переменные Описание переменной, кроме типа и класса памяти, явно или по умолчанию задает ее область действия. Класс памяти и область действия зависят не только от собственно описания, но и от места его размещения в тексте программы. Область действия идентификатора — это часть программы, в которой его можно использовать для доступа к связанной с ним области памяти. В зависимости от области действия переменная может быть локальной или глобальной. Если переменная определена внутри блока (напомню, что блок ограничен фигурными скобками), она называется локальной, область ее действия – от точки описания до конца блока, включая все вложенные блоки. Если переменная определена вне любого блока, она называется глобальной и областью ее действия считается файл, в котором она определена, от точки описания до его конца.

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

Переменные Для задания класса памяти используются следующие спецификаторы: auto – автоматическая переменная. Память под нее выделяется в стеке и при необходимости инициализируется каждый раз при выполнении оператора, содержащего ее определение. Освобождение памяти происходит при выходе из блока, в котором описана переменная. Время ее жизни – с момента описания до конца блока. Для глобальных переменных этот спецификатор не используется, а для локальных он принимается по умолчанию, поэтому задавать его явным образом большого смысла не имеет. extern – означает, что переменная определяется в другом месте программы (в другом файле или дальше по тексту). Используется для создания переменных, доступных во всех модулях программы, в которых они объявлены. static – статическая переменная. Время жизни – постоянное. Инициализируется один раз при первом выполнении оператора, содержащего определение переменной. В зависимости от расположения оператора описания статические переменные могут быть глобальными и локальными. Глобальные статические переменные видны только в том модуле, в котором они описаны. register — аналогично auto, но память выделяется по возможности в регистрах процессора. Если такой возможности у компилятора нет, переменные обрабатываются как auto.

Переменные int a; int main(){ int b; extern int x; static int с; а = 1; int а; а = 2; : : а = 3; return 0; } int х = 4; // 1 глобальная переменная а // 2 локальная переменная b // 3 переменная x определена в другом месте // 4 локальная статическая переменная с //5 присваивание глобальной переменной //6 локальная переменная а //7 присваивание локальной переменной //8 присваивание глобальной переменной //9 определение и инициализация х

Структура программы. Операции. Выражения

Структура программы Программа на языке С++ состоит из директив препроцессора, описаний и функций. Одна из функций должна иметь имя main. Пример структуры программы, содержащей функции main, f 1 и f 2: директивы препроцессора описания int main() { операторы главной функции } int fl(){ операторы функции fl } int f 2(){ операторы функции f 2 }

$Структура программы Простейшее определение функции имеет следующий формат: тип_возвращаемого_значения имя ([ параметры ]) {$

Структура программы Простейшее определение функции имеет следующий формат: тип_возвращаемого_значения имя ([ параметры ]) { операторы, составляющие тело функции } Правила использования функций: ü если функция не должна возвращать значение, указывается тип void; ü тело функции является блоком и, следовательно, заключается в фигурные скобки; ü функции не могут быть вложенными; ü каждый оператор заканчивается точкой с запятой (кроме составного оператора).

Функции ввода/вывода Основные функции ввода/вывода в стиле С: int scanf (const char* format. . ) // ввод int printf(const char* format. . ) // вывод Пример программы, использующей функции ввода/вывода в стиле С: #include <stdio. h> int main() { int i; printf("Введите целое числоn"); scanf("%d", &i); printf("Вы ввели число %d, спасибо!", i); return 0; }

Функции ввода/вывода Та же программа с использованием библиотеки классов: #include <iostream. h> int main() { int і; cout << "Введите целое числоn"; сіn >> і; cout << "Вы ввели число " << і << ", спасибо!"; return 0; }

Функции ввода/вывода Спецификации формата для функций семейства printf Спецификация Пояснение с d, i аргумент рассматривается как отдельный символ аргумент преобразуется к десятичному виду аргумент, рассматриваемый как переменная типа float или double, преобразуется в десятичную форму в виде [-]m. nnnnnne[+-]xx, где длина строки из n определяется указанной точностью. Точность по умолчанию равна 6 аргумент, рассматриваемый как переменная типа float или double, преобразуется в десятичную форму в виде [-]mmm. nnnnn, где длина строки из n определяется указанной точностью. Точность по умолчанию равна 6. используется формат %е или %f, который короче; незначащие нули не печатаются аргумент преобразуется в беззнаковую восьмеричную форму (без лидирующего нуля) вывод указателя в шестнадцатеричном формате (эта спецификация не входит в стандарт, но она существует практически во всех реализациях) аргумент является строкой: символы строки печатаются до тех пор, пока не будет достигнут нулевой символ или не будет напечатано количество символов, указанное в спецификации точности аргумент преобразуется в беззнаковую десятичную форму аргумент преобразуется в беззнаковую шестнадцатеричную форму (без лидирующих Ох) выводится символ % е, Е f g, G o р s u х, X %

Функции ввода/вывода Модификаторы формата применяются для управления шириной поля, отводимого для размещения значения. Модификаторы – это одно или два числа, первое из которых задает минимальное количество позиций, отводимых под число, а второе – сколько из этих позиций отводится под дробную часть числа (точность). Если указанного количества позиций для размещения значения недостаточно, автоматически выделяется большее количество позиций: %-min. C или %min. C; %-min. precision. C или Xmin. precision. C. Здесь С – спецификация формата из приведенной выше таблицы, min – число, задающее минимальную ширину поля.

Функции ввода/вывода Модификаторы формата Смысл модификатора precision, также задаваемого десятичным числом, зависит от спецификации формата, с которой он используется: ü при выводе строки (спецификация %s) precision указывает максимальное число символов для вывода; ü при выводе вещественного числа (спецификации %f или %e) precision указывает количество цифр после десятичной точки; ü при выводе целого числа (спецификации %d или %i), precision указывает минимальное количество выводимых цифр. Если число представляется меньшим числом цифр, чем указано в precision, выводятся ведущие (начальные) нули; ü при выводе вещественного числа (спецификации %d или %G) precision указывает максимальное количество значащих цифр, которые будут выводится. Символ минус (-) указывает на то, что значение выравнивается по левому краю и, если нужно, дополняется пробелами справа. При отсутствии минуса значение выравнивается по правому краю и дополняется пробелами слева. Перед спецификацией могут использоваться префиксы l и h, например, %lf, %hu. Префикс h с типами d, i, о, х и X указывает на то, что тип аргумента short int, а с типом u – short unsigned int.

Использование модификатора формата

Операции Операция ++ -sizeof ~ ! + & * new delete (type) Краткое описание Унарные операции увеличение на 1 уменьшение на 1 размер поразрядное отрицание логическое отрицание арифметическое отрицание (унарный минус) унарный плюс взятие адреса разадресация выделение памяти освобождение памяти преобразование типа

Операции Операция * / % + << >> < <= > >= == != Краткое описание Бинарные и тернарная операции умножение деление остаток от деления сложение вычитание сдвиг влево сдвиг вправо меньше или равно больше или равно не равно

Операции Операция & ^ | && || ? : = *= /= %= += -= <<= >>= &= != ^= , Краткое описание поразрядная конъюнкция (И) поразрядное исключающее ИЛИ поразрядная дизъюнкция (ИЛИ) логическое ИЛИ условная операция (тернарная) присваивание умножение с присваиванием деление с присваиванием остаток отделения с присваиванием сложение с присваиванием вычитание с присваиванием сдвиг влево с присваиванием сдвиг вправо с присваиванием поразрядное ИЛИ с присваиванием поразрядное исключающее ИЛИ с присваиванием последовательное вычисление

Операции увеличения и уменьшения на 1 (++ и --)

Операция определения размера sizeof

Операции отрицания (-, ! и ~) Арифметическое отрицание (унарный минус -) изменяет знак операнда целого или вещественного типа на противоположный. Логическое отрицание (!) дает в результате значение 0, если операнд есть истина (не нуль), и значение 1, если операнд равен нулю. Операнд должен быть целого или вещественного типа, а может иметь также тип указатель. Поразрядное отрицание (~), часто называемое побитовым, инвертирует каждый разряд в двоичном представлении целочисленного операнда.

Деление (/) и остаток отделения (%)

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

Операции отношения (<, <=, >, >=, ==, !=) сравнивают первый операнд со вторым. Операнды могут быть арифметического типа или указателями. Результатом операции является значение true или false (любое значение, не равное нулю, интерпретируется как true). Операции сравнения на равенство и неравенство имеют меньший приоритет, чем остальные операции сравнения.

Поразрядные операции (&, |, ^) применяются только к целочисленным операндам и работают с их двоичными представлениями. При выполнении операций операнды сопоставляются побитово (первый бит первого операнда с первым битом второго, второй бит первого операнда со вторым битом второго, и т д. ). При поразрядной конъюнкции или поразрядном И (операция обозначается &) бит результата равен 1 только тогда, когда соответствующие биты обоих операндов равны 1. При поразрядной дизъюнкции или поразрядном ИЛИ (операция обозначается |) бит результата равен 1 тогда, когда соответствующий бит хотя бы одного из операндов равен 1. При поразрядном исключающем ИЛИ (операция обозначается ^) бит результата равен 1 только тогда, когда соответствующий бит только одного из операндов равен 1.

Поразрядные операции (&, |, ^)

Логические операции (&& и ||) Операнды логических операций И (&&) и ИЛИ (||) могут иметь арифметический тип или быть указателями, при этом операнды в каждой операции могут быть различных типов. Преобразования типов не производятся, каждый операнд оценивается с точки зрения его эквивалентности нулю (операнд, равный нулю, рассматривается как false, не равный нулю – как true). Результатом логической операции является true или false. Результат операции логическое И имеет значение true только если оба операнда имеют значение true. Результат операции логическое ИЛИ имеет значение true, если хотя бы один из операндов имеет значение true. Логические операции выполняются слева направо. Если значения первого операнда достаточно, чтобы определить результат операции, второй операнд не вычисляется.

Операции присваивания (=, +=, *= и т. д. ) Операции присваивания могут использоваться в программе как законченные операторы. Формат операции простого присваивания (=): операнд_1 = операнд_2 Первый операнд должен быть L-значением, второй – выражением. Сначала вычисляется выражение, стоящее в правой части операции, а потом его результат записывается в область памяти, указанную в левой части (мнемоническое правило: «присваивание – это передача данных "налево"» ). То, что ранее хранилось в этой области памяти, естественно, теряется. В сложных операциях присваивания (+=, *=, /= и т п. ) при вычислении выражения, стоящего в правой части, используется и Lзначение из левой части. Например, при сложении с присваиванием ко второму операнду прибавляется первый, и результат записывается в первый операнд, то есть выражение а += b является более компактной записью выражения a = а + b.

Операции присваивания (=, +=, *= и т. д. )

Условная операция (? : ) Эта операция тернарная, то есть имеет три операнда. Ее формат: операнд_1 ? операнд_2 : операнд_3 Первый операнд может иметь арифметический тип или быть указателем. Он оценивается с точки зрения его эквивалентности нулю (операнд, равный нулю, рассматривается как false, не равный нулю – как true). Если результат вычисления операнда 1 равен true, то результатом условной операции будет значение второго операнда, иначе – третьего операнда. Вычисляется всегда либо второй операнд, либо третий. Их тип может различаться. Условная операция является сокращенной формой условного оператора if.

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

Выражения состоят из операндов, знаков операций и скобок и используются для вычисления некоторого значения определенного типа. Каждый операнд является, в свою очередь, выражением или одним из его частных случаев — константой или переменной. Примеры выражений: (а + 0. 12)/6 х && у || !z (t * sin(x)-1. 05 e 4)/((2 * k + 2) * (2 * k + 3)) Операции выполняются в соответствии с приоритетами. Для изменения порядка выполнения операций используются круглые скобки. Если в одном выражении записано несколько операций одинакового приоритета, унарные операции, условная операция и операции присваивания выполняются справа налево, остальные – слева направо. Результат вычисления выражения характеризуется значением и типом.

Операторы

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

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

Оператор «Выражение» Любое выражение, завершающееся точкой с запятой, рассматривается как оператор, выполнение которого заключается в вычислении выражения. Частным случаем выражения является пустой оператор (он используется, когда по синтаксису оператор требуется, а по смыслу – нет). Примеры: i++; a*=b+c; fun(i, k); //выполняется операция инкремента //выполняется умножение с присваиванием //выполняется вызов функции

Условный оператор if используется для разветвления процесса вычислений на два направления. Формат оператора: if ( выражение) оператор_1; [else оператор_2] Сначала вычисляется выражение, которое может иметь арифметический тип или тип указателя. Если оно не равно нулю (имеет значение true), выполняется первый оператор, иначе второй. После этого управление передается на оператор, следующий за условным.

Условный оператор if if ( выражение) оператор_1; [else оператор_2] true Выражение false Выражение true Оператор 1 Оператор 2 Оператор Структурная схема условного оператора if false

Условный оператор if Примеры: if (а<0) b = 1; if (a<b && (a>d || a==0)) b++; else {b *=a; a = 0; } if (a<b) { if (a<c) m = a; else m = c; } else { if (b<c) m = b; else m = c; } if (a++) b++; if (b>a) max = b; else max = a; // 1 // 2 // 3 // 4 //5

Условный оператор if Задача. Производится выстрел по мишени, изображенной Задача на рисунке. Определить количество очков. 1 очко 2 очка Мишень #include <iostream. h> int main() { float x, у; int kol; cout << "Введите координаты выстрелаn"; cin >> х >> у; if ( х*х + у*у < 1 ) kol = 2; else if( x*x + y*y < 4 ) kol = 1; else kol =0; cout << "n Очков: " << kol; return 0; }

Условный оператор if Задача. Производится выстрел по мишени, изображенной Задача на рисунке. Определить количество очков. 1 очко 2 очка Мишень #include <iostream. h> int main(){ float x, у, temp; int kol; cout << "Введите координаты выстрелаn"; cin >> x >> у; temp = x*x + y*y; kol = 0; if (temp < 4 ) kol = 1; if (temp < 1 ) kol = 2; cout << "n Очков: " << kol; return 0; }

Оператор switch (переключатель) предназначен для разветвления процесса вычислений на несколько направлений. Формат оператора: switch ( выражение ){ case константное_выражение_1: [список_операторов_1] case константное_выражение_2: [список_операторов_2] … case константное_выражение_n: [список_операторов_n] [default: операторы ] }

$Оператор switch ( выражение ){ case константное_выражение_1: [список_операторов_1] case константное_выражение_2: [список_операторов_2] case константное_выражение_n: [список_операторов_n]$

Оператор switch ( выражение ){ case константное_выражение_1: [список_операторов_1] case константное_выражение_2: [список_операторов_2] case константное_выражение_n: [список_операторов_n] [default: операторы ] } switch Выражение case 1 case 2 case n default Операторы 1 Операторы 2 Операторы n Операторы

Оператор switch Пример: программа реализует простейший калькулятор на 4 действия): #include <iostream. h> int main(){ int a, b, res; char op; cout << “n. Введите 1 -й операнд : ”; cin >> a; cout << “n. Введите знак операции”; cin >> op; cout << “n. Введите 2 -й операнд : ”; cin >> b; bool f = true; switch (op){ case ’+’: res = a + b; break; case ’-’: res = a – b; break; case ’*’: res = a * b; break; case ‘/’: res = a / b; break; default: cout <<"n. Неизвестная операция"; f = false; } if (f) cout << "n. Результат: ”; << res; return 0; }

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

Операторы цикла Начальные установки Выражение Операторы Структурные схемы операторов цикла: Операторы Модификация параметров цикла а — цикл с предусловием; Модификация параметров цикла а Выражение б б — цикл с постусловием

Цикл с предусловием while Цикл с предусловием имеет вид: while ( выражение ) оператор Выражение определяет условие повторения тела цикла, представленного простым или составным оператором. Выполнение оператора начинается с вычисления выражения. Если оно истинно (не равно false), выполняется оператор цикла. Если при первой проверке выражение равно false, цикл не выполнится ни разу. Тип выражения должен быть арифметическим или приводимым к нему. Выражение вычисляется перед каждой итерацией цикла.

Цикл с предусловием while Пример: программа печатает таблицу значений функции у*=х2+1 во введенном диапазоне: #include <stdio. h> int main(){ float Xn, Xk, Dx: printf("Введите диапазон и шаг изменения аргумента: "); scanf("%f%f%f", &Xn, &Xk, &Dx); printf("| X | Y |n"); // шапка таблицы float X = Xn; // установка параметра цикла while (X <= Xk){ // проверка условия продолжения printf("| %5. 2 f |n", X, X*X + 1); // тело цикла X += Dx; // модификация параметра } return 0; }

Цикл с предусловием while Пример: программа находит все делители целого положительного числа): #include <iostream. h> int main(){ int num; cout << "n. Введите число : "; cin >> num; int half = num/2; // половина числа int div = 2; // кандидат на делитель while (div <= half){ if (!(num % div)) cout << div <<"n"; div++; } return 0; }

Цикл с постусловием do while Цикл с постусловием имеет вид: do оператор while выражение; Сначала выполняется простой или составной оператор, составляющий тело цикла, а затем вычисляется выражение. Если оно истинно (не равно false), тело цикла выполняется еще раз. Цикл завершается, когда выражение станет равным false или в теле цикла будет выполнен какой-либо оператор передачи управления. Тип выражения должен быть арифметическим или приводимым к нему.

Цикл с постусловием do Пример: ввода: программа осуществляет #include <iostream. h> int main(){ char answer; do{ cout << "n. Купи слоника! "; cin >> answer; while (answer != 'у'); return 0; } проверку

Цикл с постусловием do Пример. Программа вычисляет квадратный корень вещественного аргумента X с заданной точностью Eps по итерационной формуле: yn = ½*(yn-1 + x/yn-1) где yn-1 – предыдущее приближение к корню (в начале вычислений выбирается произвольно), yn – последующее приближение. #include <stdio. h> #include <math. h> int main(){ double X, Eps; // аргумент и точность double Yp, Y = 1; // предыдущее и последующее приближение printf("Введите аргумент и точность: "); scanf("%lf%lf", &Х, &Eps); do{ Yp = Y; Y = (Yp + X/Yp)/2; }while (fabs(Y - Yp) >= Eps); printf("n. Kopeнь из %lf равен %lf", X, Y); return 0; }

Цикл с параметром for Цикл с параметром имеет следующий формат: for (инициализация; выражение; модификации) оператор; Инициализация используется для объявления и присвоения начальных значений величинам, используемым в цикле. В этой части можно записать несколько операторов, разделенных запятой (операцией «последовательное выполнение» ). Областью действия переменных, объявленных в части инициализации цикла, является цикл. Инициализация выполняется один раз в начале исполнения цикла. Выражение определяет условие выполнения цикла: если его результат, приведенный к типу bool, равен true, цикл выполняется. Цикл с параметром реализован как цикл с предусловием. Модификации выполняются после каждой итерации цикла и служат обычно для изменения параметров цикла. В части модификаций можно записать несколько операторов через запятую. Простой или составной оператор представляет собой тело цикла. Любая из частей оператора for может быть опущена (но точки с запятой надо оставить на своих местах!)

Цикл с параметром for Пример: оператор, вычисляющий сумму чисел от 1 до 100: for (int i = 1, s = 0; i<=100; i++) s += i; i Пример: программа печатает таблицу значений функции у=х2+1 во введенном диапазоне: #include <stdio. h> int main(){ float Xn, Xk, Dx, X; printf("Введите диапазон и шаг изменения аргумента: "); scanf("%f%f%f", &Xn, &Xk, &Dx); printf("| X | Y |n"); for (X = Xn; X<=Xk; X += Dx) printf("| %5. 2 f |n", X, X*X + 1); return 0; }

Цикл с параметром for Пример: программа находит все делители целого положительного числа: #include <iostream. h> int main(){ int num, half, div; cout << "п. Введите число : "; cin >> num; for (half = num / 2, div = 2; div <= half; div++) if (!(num % div)) cout << div <<"n"; return 0; }

Операторы передачи управления В С++ есть четыре оператора, изменяющих естественный порядок выполнения вычислений: • оператор безусловного перехода goto; • оператор выхода из цикла break; • оператор перехода к следующей итерации цикла continue; • оператор возврата из функции return.

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

Операторы break, continue, return Оператор break используется внутри операторов цикла или switch для обеспечения перехода в точку программы, находящуюся непосредственно за оператором, внутри которого находится break. Оператор перехода к следующей итерации цикла continue пропускает все операторы, оставшиеся до конца тела цикла, и передает управление на начало следующей итерации. Оператор возврата из функции return завершает выполнение функции и передает управление в точку ее вызова. Вид оператора: return [ выражение ]; Выражение должно иметь скалярный тип. Если тип возвращаемого функцией значения описан как void, выражение должно отсутствовать.

Указатели и массивы

Указатели Когда компилятор обрабатывает оператор определения переменной, например, int i=10; , он выделяет память в соответствии с типом (int) и инициализирует ее указанным значением (10). Все обращения в программе к переменной по ее имени (i) заменяются компилятором на адрес области памяти, в которой хранится значение переменной. Программист может определить собственные переменные для хранения адресов областей памяти. Такие переменные называются указателями. Итак, указатели предназначены для хранения адресов областей памяти. В С++ различают три вида указателей: • указатель на объект; • указатель на функцию; • указатель на void, отличающиеся свойствами и набором допустимых операций. Указатель не является самостоятельным типом, он всегда связан с каким-либо другим конкретным типом.

Указатель на функцию содержит адрес в сегменте кода, по которому располагается исполняемый код функции, то есть адрес, по которому передается управление при вызове функции. Указатели на функции используются для косвенного вызова функции (не через ее имя, а через обращение к переменной, хранящей ее адрес), а также для передачи имени функции в другую функцию в качестве параметра. Указатель функции имеет тип «указатель функции, возвращающей значение заданного типа и имеющей аргументы заданного типа» : тип (*имя) ( список_типов_аргументов ); Например, объявление: int (*fun) (double, double); задает указатель с именем fun на функцию, возвращающую значение типа int и имеющую два аргумента типа double.

Указатель на объект содержит адрес области памяти, в которой хранятся данные определенного типа (основного или составного). Простейшее объявление указателя на объект (в дальнейшем называемого просто указателем) имеет вид: тип *имя; где тип может быть любым, кроме ссылки и битового поля, причем тип может быть к этому моменту только объявлен, но еще не определен. Звездочка относится непосредственно к имени, поэтому для того, чтобы объявить несколько указателей, требуется ставить ее перед именем каждого из них. Например, в операторе int *а, b, *с; описываются два указателя на целое с именами а и с, а также целая переменная b. Размер указателя зависит от модели памяти. Можно определить указатель на указатель и т. д.

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

Примеры указателей Указатель может быть константой или переменной, а также указывать на константу или переменную: int i; // целая переменная const int ci = 1; // целая константа int * pi; // указатель на целую переменную const int * pci; // указатель на целую константу int * const ср = &i; // указатель-константа на целую переменную const int * const срс = &ci; // указатель-константа на целую константу

Инициализация указателей Указатели чаще всего используют при работе с динамической памятью, называемой иногда кучей (перевод с английского языка слова heap). Это свободная память, в которой можно во время выполнения программы выделять место в соответствии с потребностями. Доступ к выделенным участкам динамической памяти, называемым динамическими переменными, производится только через указатели. Время жизни динамических переменных – от точки создания до конца программы или до явного освобождения памяти. В С++ используется два способа работы с динамической памятью. Первый использует семейство функций malloc и достался в наследство от С, второй использует операции new и delete.

Способы инициализации указателей 1. Присваивание указателю адреса объекта: с помощью операции получения адреса: существующего int а = 5; // целая переменная int *р = &а; //в указатель записывается адрес а int *р (&а); // то же самое другим способом с помощью значения другого инициализированного указателя: int *r = р; с помощью имени массива или функции, которые трактуются как адрес: int b[10]; int *t = b; // массив // присваивание адреса начала массива void f(int а ){ /*. . . */ } // определение функции void (*pf)(int); // указатель на функцию pf = f; // присваивание адреса функции

Способы инициализации указателей 2. Присваивание указателю адреса области памяти в явном виде: char* vp = (char *)0 х. В 8000000; Здесь 0 х. В 8000000 – шестнадцатеричная константа, (char *) операция приведения типа: константа преобразуется к типу «указатель на char» . 3. Присваивание пустого значения: int *suxx = NULL; int *ruiez = 0;

Способы инициализации указателей 4. Выделение участка динамической присваивание ее адреса указателю: с помощью операции new: int *n = new int; int *m = new int (10); int *q = new int [10]; // 1 // 2 // 3 с помощью функции mallос: int* u = (int *)malloc(sizeof(int)); // 4 памяти и

Освобождение памяти, выделенной с помощью операции new, должно выполняться с помощью delete, а памяти, выделенной функцией mallос – посредством функции free. При этом переменнаяуказатель сохраняется и может инициализироваться повторно. Для того чтобы использовать malloc, требуется подключить к программе заголовочный файл < malloc. h>. Приведенные выше динамические переменные уничтожаются следующим образом: delete n; delete m; delete [] q; free (u); Если память выделялась с помощью new[], для освобождения памяти необходимо применять deleted[]. Размерность массива при этом не указывается.

Операции с указателями С указателями можно выполнять следующие операции: • • разадресация или косвенное обращение к объекту (*), присваивание, сложение с константой, вычитание, инкремент (++), декремент (--), сравнение, приведение типов. При работе с указателями часто используется операция получения адреса (&).

Операции с указателями Операция разадресации или разыменования предназначена для доступа к величине, адрес которой хранится в указателе. Эту операцию можно использовать как для получения, так и для изменения значения величины (если она не объяв ена как л константа): char а; // переменная типа char *р = new char; /* выделение памяти под указатель и под динамическую переменную типа char */ *р = 'Ю'; а = *р; // присваивание значения обеим переменным

Операции с указателями Присваивание без явного приведения типов допускается в двух случаях: • указателям типа void*; • если тип указателей справа и слева от операции присваивания один и тот же. Таким образом, неявное преобразование выполняется только к типу void*. Значение 0 неявно преобразуется к указателю на любой тип. Присваивание указателей на объекты указателям на функции (и наоборот) недопустимо. Запрещено и присваивать значения указателям-константам, впрочем, как и константам любого типа (присваивать значения указателям на константу и переменным, на которые ссылается указатель-константа, допускается).

Операции с указателями Арифметические операции с указателями (сложение с константой, вычитание, инкремент и декремент) автоматически учитывают размер типа величин, адресуемых указателями. Эти операции применимы только к указателям одного типа и имеют смысл в основном при работе со структурами данных, последовательно размещенными в памяти, например, с массивами. Инкремент перемещает указатель к следующему элементу массива, декремент – к предыдущему. Фактически значение указателя изменяется на величину sizeof (тип). Если указатель на определенный тип увеличивается или уменьшается на константу, его значение изменяется на величину этой константы, умноженную на размер объекта данного типа, например: short * р = new short [5]; р++; long * q = new long [5]; q++; // значение р увеличивается на 2 // значение q увеличивается на 4 Разность двух указателей — это разность их значений, деленная на размер типа в байтах (в применении к массивам разность указателей, например, на третий и шестой элементы равна 3). Суммирование двух указателей не допускается.

Ссылки Ссылка представляет собой синоним имени, указанного при инициализации ссылки. Ссылку можно рассматривать как указатель, который всегда разымено ывается. Формат объявления ссылки: в тип & имя; где тип – это тип величины, на которую указывает ссылка, & - оператор ссылки, означающий, что следующее за ним имя является именем переменной ссылочного типа, например: int kol; int& pal = kol; // ссылка pal - альтернативное имя для kol const char& CR = 'n': // ссылка на константу

Массивы При использовании простых переменных каждой области памяти для хранения данных соответствует свое имя. Если с группой величин одинакового типа требуется выполнять однообразные действия, им дают одно имя, а различают по порядковому номеру. Это позволяет компактно записывать множество операций с помощью циклов. Конечная именованная последовательность однотипных величин называется массивом. Описание линейного (одномерного) массива в программе отличается от описания простой переменной наличием после имени квадратных скобок, в которых задается количество элементов массива (размерность): float а [10]; // описание массива из 10 вещественных чисел При описании массивов квадратные скобки являются элементом синтаксиса, а не указанием на необязательность конструкции. Элементы массива нумеруются с нуля.

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

Массивы В следующем примере подсчитывается сумма элементов массива. #include <iostream. h> int main(){ const int n = 10; int i, sum; int marks[n] = {3, 4, 5, 4, 4}; for (i = 0; sum = 0; i<n; i++) sum += marks[i]; cout << "Сумма элементов: " << sum; return 0; }

Стандартные алгоритмы работы с одномерными массивами 1. Ввод элементов массива с клавиатуры: const int n=20; int b[n]; int i; for (i=0; i<n; i++) cin >> b[i]; 2. Ввод элементов массива с помощью генератора случайных чисел: const int n=20; int b[n]; int i; randomize(); for (i=0; i<n; i++) b[i]=random(100) - 50; // генерирование случайных // чисел в диапазоне [-50; 50].

Стандартные алгоритмы работы с одномерными массивами 3. Вывод элементов массива на экран: const int n=20; int b[n]; int i; for (i=0; i<n; i++) cout << b[i]; 4. Поиск максимального элемента в массиве и запоминание позиции максимального элемента в массиве: const int n=20; int b[n]; int i, n_max; max=b[0]; for (i=1; i<n; i++) if (max >b[i]) { max = b[i]; n_max=i; } cout <<”Максимальный элемент массива b[”<<n_ max<<”]=”<<max;

Стандартные алгоритмы работы с одномерными массивами 5. Поиск минимального элемента в массиве и запоминание позиции минимального элемента в массиве: const int n=20; int b[n]; int i, n_min; min=b[0]; for (i=1; i<n; i++) if (min >b[i]) { min = b[i]; n_min=i; } cout <<”Минимальный элемент массива b[”<<n_ min<<”]=”<<min;

Стандартные алгоритмы работы с одномерными массивами 6. Сортировка целочисленного массива методом выбора. #include <iostream. h> int main(){ const int n = 20; // количество элементов массива int b[n]; // описание массива int і; for (і = 0; i<n; і++) сіn >> b[i]; // ввод массива for (і = 0; і<n-1; і++) { // n-1 раз ищем наименьший элемент // принимаем за наименьший первый из рассматриваемых элементов int imin = i; // поиск номера минимального элемента из неупорядоченных for (int j = i + 1; j<n; j++) // если нашли меньший элемент, запоминаем его номер: if (b[j] < b[imin]) imin = j; int a = b[i]; // обмен элементов b[i] = b[imin]; // с номерами b[imin] = a; // i и imin } // вывод упорядоченного массива: for (i =0; i<n; i++) cout << b[i] << “ ”; return 0; }

Стандартные алгоритмы работы с одномерными массивами 7. Сортировка целочисленного массива методом пузырьковой сортировки. // Эта программа сортирует значения массива в возрастающем порядке #include <iostream. h> #include <iomanip. h> main() { const int array. Size = 10; int a[array. Size] = {2, 6, 4, 8, 10, 12, 89, 68, 45, 37}; int hold; cout << "Элементы данных в исходном порядке" << endl; for (int і = 0; і < array. Size; і++) cout << setw(4) << a[i]; for (int pass = 1; pass < array. Size; pass++) // проход for (і = 0; і < array. Size - 1; і++) // один проход if (a[i] > a[i + 1]) { // одно сравнение hold = a[i]; // одна перестановка a[i] = a[i + 1]; а[і + 1] = hold; } cout <<endl << "Элементы данных в порядке возрастания " << endl; for (i = 0; i < array. Size; i++) cout << setw(4) << a[i]; cout << endl; return 0; }

Стандартные алгоритмы работы с одномерными массивами Процесс обмена элементов массива с номерами і и іmin через буферную переменную а на і-м проходе цикла проиллюстрирован на рисунке. Цифры около стрелок обозначают порядок действий A Индекс: Массив: i imin 2 1 3 a Можно описать указатель, присвоить ему адрес начала массива и работать с массивом через указатель. Следующий фрагмент программы копирует все элементы массива а в массив b: int a[100], b[100]; int *pa = а; // или int *p = &a[0]; int *pb = b; for (int i = 0; i<100; i++) *pb++ = *pa++; // или pb[i] = pa[i];

Динамические массивы создают с помощью операции new, при этом необходимо указать тип и размерность, например: int n = 100; float *р = new float [n]; Динамические массивы нельзя при создании инициализировать, и они не обнуляются. Преимущество динамических массивов состоит в том, что размерность может быть переменной, то есть объем памяти, выделяемой под массив, определяется на этапе выполнения программы. Доступ к элементам динамического массива осуществляется точно так же, как к статическим, например, к элементу номер 5 приведенного выше массива можно обратиться как р[5] или *(р+5).

Динамические массивы Альтернативный способ создания динамического массива – использование функции mallос библиотеки С: int n = 100; float *q = (float *) malloc(n * sizeof(float)); Операция преобразования типа, записанная перед обращением к функции mallос, требуется потому, что функция возвращает значение указателя типа void*, а инициализируется указатель на float. Память, зарезервированная под динамический массив с помощью new [], должна освобождаться оператором delete [], а память, выделенная функцией mallос – посредством функции free, например: delete [] р; free (q); При несоответствии способов выделения и освобождения памяти результат не определен. Размерность массива в операции delete не указывается, но квадратные скобки обязательны.

Многомерные массивы задаются указанием измерения в квадратных скобках, например, оператор каждого int matr [6][8]; задает описание двумерного массива из 6 строк и 8 столбцов. В памяти такой массив располагается в последовательных ячейках построчно. Для доступа к элементу многомерного массива указываются все его индексы, например, matr[i][j], или более экзотическим способом: *(matr[i]+j) или *(*(matr+i)+j). Это возможно, поскольку matr[i] является адресом начала i-й строки массива.

Многомерные массивы При инициализации многомерного массива он представляется либо как массив из массивов, при этом каждый массив заключается в свои фигурные скобки (в этом случае левую размерность при описании можно не указывать), либо задается общий список элементов в том порядке, в котором элементы располагаются в памяти: int mass 2 [][2] = { {1, 1}, {0, 2}, {1, 0} }; int mass 2 [3][2] = {1, 1, 0, 2, 1, 0};

Стандартные алгоритмы работы с многомерными массивами 1. Ввод элементов массива с клавиатуры: const int n=20; int b[n][n]; int i; for (i=0; i<n; i++) for (j=0; j<n; j++) cin >> b[i][j]; 2. Ввод элементов массива с помощью генератора случайных чисел: const int n=20; int b[n][n]; int i; randomize(); for (i=0; i<n; i++) for (j=0; j<n; j++) b[i][j]=random(100) - 50; // генерирование случайных // чисел в диапазоне [-50; 50].

Стандартные алгоритмы работы с многомерными массивами 3. Вывод элементов массива на экран: const int n=20; int b[n][n]; int i; for (i=0; i<n; i++) for (j=0; j<n; j++) cout << b[i][j]; 4. Поиск максимального элемента в массиве и запоминание позиции максимального элемента в массиве: const int n=20; int b[n]; int i, n_imax, n_jmax; max=b[0][0]; for (i=0; i<n; i++) for (j=0; j<n; j++) if (max >b[i][j]) { max = b[i][j]; n_imax=i; n_jmax=j } cout <<”Максимальный элемент массива b[” <<n_ imax<<“, ”<<n_jmax<<”]=”<<max;

Стандартные алгоритмы работы с многомерными массивами 5. Поиск минимального элемента в массиве и запоминание позиции минимального элемента в массиве: const int n=20; int b[n]; int i, n_imin, n_jmax; min=b[0][0]; for (i=0; i<n; i++) for (j=0; j<n; j++) if (min >b[i][j]) { min = b[i][j]; n_imin=i; n_jmin=j; } cout <<”Минимальный элемент массива b[”<<n_ imin <<”, ”<<n_jmin<<”]=”<<min;

Введение в обработку символов и строк

Строки Строка – это последовательность символов, обрабатываемая как единый модуль. Строка может включать буквы, цифры и разнообразные специальные символы, такие как +, -, *, /, $ и другие. Литеральные константы или строковые константы записываются в С++ в двойных кавычках следующим образом: "John Q. Doe" (имя) "9999 Main Street" (адрес улицы) "Waltham, Massachusetts" (город и штат) "(201)555 -1212" (номер телефона) Строка в С++ – это массив символов, оканчивающийся нулевым символом (''). Строка доступна через указатель на первый символ в строке.

Описание строк Строка может быть объявлена либо как массив символов, либо как переменная типа char*. Каждое из объявлений char color[] = "синий"; char *color. Ptr = "синий"; присваивает переменной строке начальное значение «синий» . Первое объявление создает массив из 6 элементов color содержащий символы ‘с’, ‘и’, ‘н’, ‘и’, ‘й’ и ‘’. Второе объявление создает переменную указатель color. Ptr, который указывает на строку «синий» где-то в памяти. Объявление char color[] = {"синий"} может быть записано char color[ ] = {'c', 'и', 'н', 'и', 'й', ''};

Ввод-вывод строк Для ввода-вывода строк используются как уже известные нам объекты cin и cout, так и функции, унаследованные из библиотеки С. Первый способ: #include <iostream. h> int main() { const int n = 80; char s[n]; cin >> s; cout << s << endl; //ввод строки, состоящей из одного слова return 0; } В данном случае ввод выполняется до первого пробельного символа (то есть пробела, знака табуляции или символа перевода строки “n”).

Ввод-вывод строк Можно ввести слова входной строки в отдельные строковые переменные: #include <iostream. h> int main() { const int n = 80; char s[n], t[n], r[n]; cin >> s » t >> r; cout << s << endl << t << endl << r << endl; return 0; }

Ввод-вывод строк Если требуется ввести строку, состоящую из нескольких слов, в одну строковую переменную, используются методы getline или get класса iostream, объектом которого является cin. #include <iostream. h> int main(){ const int n = 80; char s[n]; cin. getline(s, n); cout << s << endl; cin. get(s, n); cout << s << endl; return 0; } Метод getline считывает из входного потока n - 1 символов или менее (если символ перевода строки встретится раньше) и записывает их в строковую переменную s. Символ перевода строки также считывается (удаляется) из входного потока, но не записывается в строковую переменную, вместо него размещается завершающий 0. Если в строке исходных данных более n - 1 символов, следующий ввод будет выполняться из той же строки, начиная с первого несчитанного символа. Метод get работает аналогично, но оставляет в потоке символ перевода строки. В строковую переменную добавляется завершающий 0.

Ввод-вывод строк Если в программе требуется ввести несколько строк, метод getline удобно использовать в заголовке цикла, например: #include <iostream. h> int main(){ const int n = 80; char s[n]; while (cin. getline(s, n)) { cout << s << endl; // обработка строки } return 0: }

Ввод-вывод строк Можно использовать для ввода строки функцию scanf, а для вывода - printf, задав спецификацию формата %s: #include <stdio. h> int main(){ const int n = 10; char s[n]; scanf(“%s”, s); printf(“%s“, s); return 0; } Ввод будет выполняться до первого пробельного символа. Чтобы ввести строку, состоящую из нескольких слов, используется спецификация %c (символы) с указанием максимального количества вводимых символов, например: scanf(“%10 c“, s); Количество символов может быть только целой константой. При выводе можно задать перед спецификацией %s количество позиций, отводимых под строку: printf(“%15 s“, s): Строка при этом выравнивается по правому краю отведенного поля. Если заданное количество позиций недостаточно для размещения строки, оно игнорируется, и строка выводится целиком.

Ввод-вывод строк Библиотека содержит также функции, специально предназначенные для ввода -вывода строк: gets и puts. Предыдущий пример с использованием этих функций выглядит так: #include <stdio. h> int main(){ const int n = 10; char s[n]; gets(s); puts(s): return 0: } Функция gets (s) читает символы с клавиатуры до появления символа новой строки и помещает их в строку s (сам символ новой строки в строку не включается, вместо него в строку заносится нуль-символ). Функция возвращает указатель на строку s, а в случае возникновения ошибки или конца файла — NULL. Функция puts (s) выводит строку s на стандартное устройство вывода, заменяя завершающий 0 символом новой строки. Возвращает неотрицательное значение при успехе или EOF при ошибке.

Операции со строками Прототип функции strcpy(s 1, s 2) strncpy(s 1, s 2, n) strcat(s 1, s 2) strncat(s 1, s 2, n) Описание функции Копирует строку s 2 в массив символов s 1. Возвращает значение s 1. Копирует не более п сиволов из строки s 2 в массив символов s 1. Возвращает значение s 1. Добавляет строку s 2 к строке s 1. Первый символ строки s 2 записывается поверх завершающего нулевого символа строки s 1. Возвращает значение s 1. Добавляет не более n символов строки s 2 в строку s 1. Первый символ из s 2 записывается поверх завершающего нулевого символа в s 1. Возвращает значение s 1.

Операции со строками Прототип функции strcmp (s 1, s 2) strcmp (s 1, s 2, n) Описание функции Сравнивает строки s 1 и s 2. Функция возвращает значение 0, меньшее, чем 0 или большее, чем 0, если s 1 соответственно равна, меньше или больше, чем s 2. Сравнивает до n символов строки s 1 со стокой s 2. функция возвращает значение 0, меньшее, чем 0 или большее, чем 0, если s 1 соответственно равна, меньше или больше, чем s 2.

Операции со строками Прототип функции strtok(s 1, s 2) strlen(s) Описание функции Последовательность вызовов strtok разбивает строку s 1 на «лексемы» - логические куски, такие, как слова в строке текста, разделенные символами, содержащимися в строке s 2. Первый вызов содержит в качестве первого аргумента s 1, а последующие вызовы для продолжения обработки той же строки, содержат в качестве первого аргумента NULL. При каждом вызове возвращается указатель на текущую лексему. Если при вызове функции лексем больше нет, возвращается NULL. Определяет длину строки s. Возвращает количество символов, предшествующих завершающему нулевому символу.

Работа с символами Для хранения отдельных символов используются переменные типа char. Их ввод-вывод также может выполняться как с помощью классов ввода-вывода, так и с помощью функций библиотеки. При использовании классов ввод-вывод осуществляется как с помощью операций помещения в поток << и извлечения из потока >>, так и методов get() и getchar(). Ниже приведен пример применения операций: #include <iostream. h> int main(){ char с, d, e; cin >> с; cin >> d >> e; //нельзя ввести таким способом символ пробела cout << с << d << endl; return 0; }

Работа с символами Для ввода любого символа, включая воспользоваться методами get() или get(c); пробельные, можно #include <iostream. h> int main() { char с, d, e; с = cin. get(); cin. get(d); cin. get(e); cout << с << d << endl; return 0; } Метод get () возвращает код извлеченного из потока символа или EOF, а метод get (с) записывает извлеченный символ в переменную, переданную ему в качестве аргумента, и возвращает ссылку на поток.

Работа с символами В заголовочном файле <stdio. h> определена функция getchar() для ввода символа со стандартного ввода, а также putchar() для вывода: #include <stdio. h> int main() { char с, d; с = getchar(); putchar(c); d = getchar(); putchar(d); return 0; }

Скачать презентацию Основы программирования Автор Черкес Наталия Борисовна Содержание

Основы программирования.pptx

Количество слайдов: 149