1.Понятие алгоритма и программы.

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

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

Формальные признаки алгоритма.

Формальные признаки алгоритмов

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

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

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

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

Массовость - алгоритм должен быть применим к разным наборам исходных данных.

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

Блок-схемы алгоритмов.

Наименование Обозначение Функция Блок начало-конец (пуск-остановка)

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

Блок вычислений (вычислительный блок)

Выполнение одной или нескольких операций, обработка данных любого вида (изменение значения данных, формы представления, расположения). Внутри фигуры записывают непосредственно сами операции, например, операцию присваивания: a = 10*b + c.

Логический блок (блок условия)

Отображает решение или функцию переключательного типа с одним входом и двумя или более альтернативными выходами, из которых только один может быть выбран после вычисления условий, определенных внутри этого элемента. Вход в элемент обозначается линией, входящей обычно в верхнюю вершину элемента. Если выходов два или три то обычно каждый выход обозначается линией, выходящей из оставшихся вершин (боковых и нижней). Если выходов больше трех, то их следует показывать одной линией, выходящей из вершины (чаще нижней) элемента, которая затем разветвляется. Соответствующие результаты вычислений могут записываться рядом с линиями, отображающими эти пути. Примеры решения: в общем случае − сравнение (три выхода: >, <, =); в программировании − условные операторы if (два выхода: true, false) и case (множество выходов).

Предопределенный процесс

Символ отображает выполнение процесса, состоящего из одной или нескольких операций, который определен в другом месте программы (в подпрограмме, модуле). Внутри символа записывается название процесса и передаваемые в него данные. Например, в программировании − вызов процедуры или функции.

Данные (ввод-вывод)

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

Граница цикла

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

Соединитель

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

Комментарий

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

Пример:блок-схема алгоритма Евклида для определения НОД двух чисел.

Нод-наименьший общий делитель

Алгоритм Евклида

1. Ввести a и b .

2. Если b == 0 , то Ответ: а . Конец .

3. Заменить r = "остаток от деления а на b ", а = b , b = r .

4. Идти на 2.

a	b
112	88
88	24
24	16
16	8
8	0

2.Программирование в среде Visual Studio,типы проектов. С++.

Microsoft Visual Studio — линейка продуктов компании Майкрософт, включающих интегрированную среду разработки программного обеспечения и ряд других инструментальных средств. Данные продукты позволяют разрабатывать как консольные приложения, так и приложения с графическим интерфейсом, в том числе с поддержкой технологии Windows Forms, а также веб-сайты, веб-приложения, веб-службы как в родном, так и в управляемом кодах для всех платформ, поддерживаемых Microsoft Windows, Windows Mobile, Windows CE, .NET Framework, .NET Compact Framework и Microsoft Silverlight.

Visual Studio включает в себя редактор исходного кода с поддержкой технологии IntelliSense и возможностью простейшего рефакторинга кода. Встроенный отладчик может работать как отладчик уровня исходного кода, так и как отладчик машинного уровня. Остальные встраиваемые инструменты включают в себя редактор форм для упрощения создания графического интерфейса приложения, веб-редактор, дизайнер классов и дизайнер схемы базы данных. Visual Studio позволяет создавать и подключать сторонние дополнения (плагины) для расширения функциональности практически на каждом уровне, включая добавление поддержки систем контроля версий исходного кода (как например, Subversion и Visual SourceSafe), добавление новых наборов инструментов (например, для редактирования и визуального проектирования кода на предметно-ориентированных языках программирования или инструментов для прочих аспектов цикла разработки программного обеспечения (например, клиент Team Explorer для работы с Team Foundation Server).

«Родной”

Машинный код (также употребляются термины собственный код, или платформенно-ориентированный код, или родной код, или нативный код — от англ. native code) — система команд конкретной вычислительной машины, которая интерпретируется непосредственно микропроцессором или микропрограммами данной вычислительной машины.

Каждая модель процессора имеет свой собственный набор команд, хотя во многих моделях эти наборы команд сильно перекрываются. Говорят, что процессор A совместим с процессором B, если процессор A полностью «понимает» машинный код процессора B. Если процессор A знает несколько команд, которых не понимает процессор B, то B несовместим с A.

“Управляемый”

Управля́емый код (англ. managed code) — термин, введённый Microsoft для обозначения кода программы, исполняемой под «управлением» виртуальной машины .NET[1][2] — Common Language Runtime. При этом обычный машинный код называется неуправля́емым кодом (англ. unmanaged code).

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

Консольного приложения,

Управля́емый код (англ. managed code) — термин, введённый Microsoft для обозначения кода программы, исполняемой под «управлением» виртуальной машины .NET[1][2] — Common Language Runtime. При этом обычный машинный код называется неуправля́емым кодом (англ. unmanaged code).

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

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

идеология работы приложений на базе MFC и Windows Forms.

Пакет Microsoft Foundation Classes (MFC) — библиотека на языке C++, разработанная Microsoft и призванная облегчить разработку GUI-приложений для Microsoft Windows путем использования богатого набора библиотечных классов.

Библиотека MFC, как и её основной конкурент, Borland VCL, облегчает работу с GUI путем создания каркаса приложения — «скелетной» программы, автоматически создаваемой по заданному макету интерфейса и полностью берущей на себя рутинные действия по его обслуживанию (отработка оконных событий, пересылка данных между внутренними буферами элементов и переменными программы и т. п.). Программисту после генерации каркаса приложения необходимо только вписать код в места, где требуются специальные действия. Каркас должен иметь вполне определенную структуру, поэтому для его генерации и изменения в Visual C++ предусмотрены мастера.

Кроме того, MFC предоставляет объектно-ориентированный слой оберток (англ. wrappers) над множеством функций Windows API, делающий несколько более удобной работу с ними. Этот слой представляет множество встроенных в систему объектов (окна, виджеты, файлы и т. п.) в виде классов и опять же берет на себя рутинные действия вроде закрытия дескрипторов и выделения/освобождения памяти.

Windows Forms — название интерфейса программирования приложений (API), отвечающего за графический интерфейс пользователя и являющегося частью Microsoft .NET Framework. Данный интерфейс упрощает доступ к элементам интерфейса Microsoft Windows за счет создания обертки для существующего Win32 API в управляемом коде. Причем управляемый код — классы, реализующие API для Windows Forms, не зависят от языка разработки. То есть программист одинаково может использовать Windows Forms как при написании ПО на C#, С++, так и на VB.Net, J# и др.

С одной стороны Windows Forms рассматривается как замена более старой и сложной библиотеке MFC, изначально написанной на языке C++, но с другой стороны, WF не предлагает парадигму, сравнимую с MVC. Для исправления этой ситуации и реализации данного функционала в WF существуют сторонние библиотеки. Одной из наиболее используемых подобных библиотек является User Interface Process Application Block, выпущенная специальной группой Microsoft, занимающейся примерами и рекомендациями, для бесплатного скачивания. Эта библиотека также содержит исходный код и обучающие примеры для ускорения обучения.

??3.Концепция памяти.

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

Концепция памяти как хранилища значений, содержимое которого может

обновляться операторами программы, является фундаментальной в императивном

программировании.

Переменные и области действия

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

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

Локальные переменные объявляются внутри функции и вне ее тела недоступны. Вернитесь к последнему примеру. Там программа состоит из двух функций. В main () объявляются переменные number, s и name (две последних — не простые переменные, а массивы, но это несущественно). В функции Convert объявлены grp1, grp2 и grp3.

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

.Глобальные,статические,константные переменные.

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

void some_function(void)

{    int count;    float result; }

Конста́нта в программировании — способ адресования данных[прим. 1], изменение которых рассматриваемой программой запрещено.Использование констант, особенно, именованных — мощный инструмент, повышающий надёжность и безошибочность программ.

ГЛОБАЛЬНЫЕ ПЕРЕМЕННЫЕ

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

#include <iostream.h>

int number = 1001;

void first_change(void)

(

cout << "значение number в first_cbange " << number << endl;

number++;

}

void second_change(void)

{

cout << "значение number в second_change " << number << endl;

number++;

}

void main(void)

{

cout << "значение number в main " << number << endl;

number++;

first_change () ;

second_change();

}

Cтатические переменные

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

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

Пример объявления статической переменной:

int GetOpenPositionsNumber()

{

static int Count = 0;

...

}

Статические переменные

#include <windows.h>

#include <iostream>

#include <conio.h>

#include <time.h>

 

using namespace std;

 

void Throw_coin(){

static int i=-1;

if(i==-1)srand((unsigned int)clock());

 

int Rnd = rand()%2;

  if(Rnd == i) cout << "СНОВА ";

  cout << (Rnd ? "ОРЕЛ!" : "РЕШКА!") << endl;

i = Rnd;

}

 

int main(){

SetConsoleOutputCP(1251);// Для отображения русских символов

 

cout << "--- ? ОРЕЛ ИЛИ РЕШКА ? ---\n\n";

cout << "Нажмите любую клавишу, чтобы бросить монету\n";

cout << "\'Esc\' - Для выхода\n\n";

 

while(getch() != 27)Throw_coin();

return 0;

}

Базовые типы данных С++.Привести примеры.

4.Структура выбора.

Есть структура выбора ветвящаяся, а есть структура множественного выбора.

If

Формат оператора:

if (выражение) оператор-1; [else оператор-2;]

Выполнение оператора if начинается с вычисления выражения.

Далее выполнение осуществляется по следующей схеме:

- если выражение истинно (т.е. отлично от 0), то выполняется оператор-1.

- если выражение ложно (т.е. равно 0),то выполняется оператор-2.

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

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

Пример:

if (i < j) i++: else { j = i-3; i++; }

Этот пример иллюстрирует также и тот факт, что на месте оператор-1, так же как и на месте оператор-2 могут находиться сложные конструкции.

Допускается использование вложенных операторов if. Оператор if может быть включен в конструкцию if или в конструкцию else другого оператора if. Чтобы сделать программу более читабельной, рекомендуется группировать операторы и конструкции во вложенных операторах if, используя фигурные скобки. Если же фигурные скобки опущены, то компилятор связывает каждое ключевое слово else с наиболее близким if, для которого нет else.

if/else

if (УСЛОВИЕ){

Код, который выполняется, если условие выполнено

}else{

Код, который выполняется, если условие не выполнено

}

Структура множественного выбора switch

switch

switch (Переменная){

case значение1:

Код, выполняемый, в случае, если

Переменная имеет значение 1

break;

case значение2:

Код, выполняемый, в случае, если

Переменная имеет значение 2

break;

case значение3:

Код, выполняемый, в случае, если

Переменная имеет значение 2

break;

default

Код, выполняемый, в случае, если

Переменная имеет не равное ни одному

из перечисленных

break;

}

УСЛОВИЕМ может быть любое логическое выражение или переменная типа bool

Логические операторы:

&& И A && B верно, если верно A и верно B

|| ИЛИ A || B верно, если верно либо A либо B

! НЕ !A верно, если А – неверно

Операторы сравнения:

>  Больше a>b

<  Меньше a<b

>= Больше или равно a>=b

<= Меньше или равно a<=b

== Равно a==b

!= Не равно a!=b

Применение,синтаксис,примеры.

ПРИМЕР:if

#include <windows.h>

#include <iostream>

using namespace std;

int main(){

SetConsoleOutputCP(1251);// Для отображения русских символов

int Grad;

cout<<"Grad = ";

cin >> Grad;

cout << ( Grad >= 60 ? "Зачет!" : "Незачет!") << endl;

return 0;

}

ПРИМЕР: if/else

#include <stdio.h>

main() /* главная функция*/

{

int x, y, z, max ; /* описание переменных*/

printf(" Введите три числа :\n ");

scanf(" %d %d %d ", &x, &y, &z); /*ввод трех чисел*/

if( x > y) /*операции сравнивания*/

max=x;

else

max=y;

if ( z>max)

max=z;

printf(" Максимальное из (%d, %d, %d)= %d \n",x, y, z, max);

}

ПРИМЕР: switch

#include <windows.h>

#include <iostream>

using namespace std;

int main(){

SetConsoleOutputCP(1251);// Для отображения русских символов

int nVal;

cout<<"Введите число от одного до трех \n";

cin >> nVal;

switch(nVal){

case 1:

cout << "Вы ввели число один" << endl;

break;

case 2:

cout << "Вы ввели число два" << endl;

break;

case 3:

cout << "Вы ввели число три" << endl;

break;

default:

cout << "Введенное Вами значение не является числом\

от одного до трех!" << endl;

break;

}

return 0;

}

5.Структуры повторения for.

Циклы "For" позволяют выполнять цикл до тех пор, пока не будет выполнено определенное условие.

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

Синтаксис, примеры организации циклов.

СИНТАКСИС ОПЕРАТОРА for:

for(инициализация; условие выхода; приращение){

Код, который будет повторяться пока условие выполнено

}

ПРИМЕР:

cout << "ASCII таблица:\n" << endl;

for(int ch = 0; ch<=255; ch++){

cout << "ASCII код: " << ch <<" \tсимвол "<< (char)ch << endl;

}

Пример2

cout << "ASCII таблица:\n" << endl;

int ch=0; //инициализация

while(ch<255){ //условие выхода

cout << "ASCII код: " << ch <<" \tсимвол "<< (char)ch << endl;

ch = ch+1; //приращение

}

6.Структуры повторения while,do/while.

Структура повторения do/while похожа на структуру while. В структуре while условие продолжения циклов проверяется в начале цикла, до того, как выполняется тело цикла. В структуре do/while проверка условия продолжения циклов производится после того, как тело цикла выполнено, следовательно, тело цикла будет выполнено по крайней мере один раз. Когда do/while завершается, выполнение программы продолжается с оператора, следующего за предложением while . Отметим, что в структуре do/while нет необходимости использовать фигурные скобки, если тело состоит только из одного оператора. Но фигурные скобки обычно все же ставят, чтобы избежать путаницы между структурами while и do/while . Например,

while (условие)

обычно рассматривается как заголовок структуры while. Структура do/while без фигурных скобок и с единственным оператором в теле имеет вид

do

оператор

while (условие);

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

do {

оператор

} while (условие);

Итак, как же работает оператор do/while? Рассмотрим конструкцию вида

do

оператор

while (условие);

следующий оператор;

Сначала выполняется оператор, затем вычисляется выражение. Если его результат отличен от нуля (true), тогда управление переходит обратно к началу оператора do, процесс повторяется. Когда значение выражения - ноль (false), тогда управление переходит к следующему оператору.

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

do {

cout << "\n Введите положительное целое число: ";

cin >> n;

} while (n <= 0);

Пользователю предлагается ввести положительное целое число. Отрицательное значение или ноль заставляют цикл выполняться снова, и пользователь должен вводить другое значение. Управление выходит из цикла только после того, как пользователь вводит положительное целое число. 

Синтаксис,примеры организации циклов.

1while(УСЛОВИЕ){

Код, который

будет повторяться

пока условие выполнено

}

while(условие)

{

оператор_1;

оператор_2;

....

оператор

}

do{

Код, который

будет

повторяться

пока условие

выполнено

}while(УСЛОВИЕ);

Пример do/while:

#include <windows.h>

#include <iostream>

#include <conio.h>

using namespace std;

int main(){

SetConsoleOutputCP(1251);// Для отображения русских символов

cout << "Для окончания программы нажмите клавишу \’q\’\n" << endl;

char ch;

do{

ch = getch();

cout << "ASCII код: " << (int)ch <<" \tсимвол "<< ch << endl;

}while(ch != 'q');

return 0;

}

Пример while:

while (p != 0) {

*q = *p; // скопировать символ

q = q+1;

p = p+1;

}

*q = 0;

Пример while:

while (a>10) {

b = c;

c = b+1;

a = b*c;

}

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

Структура следования встроена в С++. Пока не указано иное, компьютер выполняет операторы С++ один за другим в той последовательности, в которой они записаны. Со структурами выбора мы познакомились в прошлый раз. Напомним еще раз. С++ обеспечивает три типа структур выбора альтернатив:

структура с единственным выбором if (ЕСЛИ) выполняет некоторое действие, если проверяемое условие истинно, или пропускает его, если ложно; структура с двойным выбором if/else (ЕСЛИ-ИНАЧЕ), выполняет одно действие, если условие истинно и другое действие, если оно ложно; структура с множественным выбором switch (ВЫБОР), выполняет одно из множества действий в зависимости от значения проверяемого выражения.

Сегодня, мы познакомимся со структурами повторения. С++ обеспечивает три типа структур повторения (циклов), называемых while (ПОКА), do-while (ЦИКЛ-ПОКА) и for (ЦИКЛ).

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

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

ПОКА имеются незачеркнутые элементы в моем списке покупок Сделать следующую покупку и вычеркнуть ее из списка

описывает повторные действия при посещении магазина. Условие "имеются незачеркнутые элементы в моем списке покупок" может быть истинным или ложным. Если оно истинно, то осуществляется действие "Сделать следующую покупку и вычеркнуть ее из списка". Это действие будет повторяться до тех пор, пока условие остается истинным. Оператор (или операторы), записанные в цикле while (ПОКА) составляют тело while, которое может быть отдельным или составным оператором. Очевидно, что когда-нибудь условие станет ложным (когда будет осуществлена и вычеркнута из списка последняя покупка). Начиная с этого момента повторение прерывается и выполняется первое действие, следующее за структурой повторения.

Обобщенная форма цикла while:

while ( выражение ) оператор;

Вначале вычисляется выражение. Если результат отличен от нуля (true), тогда выполняется оператор и управление переходит обратно к началу цикла while. Это приводит к выполнению тела цикла while, а именно оператора, который будет выполняться до тех пор, пока выражение не станет равным нулю (false). Затем управление передается следующему оператору. Таким образом, цикл может выполняться ноль или более раз. Например:

/* Пример выводит на экрон 5 строк типа "Строка" + "индекс" +

"выводится в цикле", где "индекс" меняется от 0 до 4 */

#include < iostream.h >

void main()

{

int i = 0; /*Объявление и инициализация переменной i*/

cout << "\n Начало цикла";

while (i != 5) /*Проверяется выражение (i != 5),

если результат - истина, выполняется операторы тела цикла,

в противном случае управление передается оператору, следующему за циклом. */

{

cout << "Строка " << i << "выводится в цикле \n";

i++;

}

cout << "\n Оператор, следующий за циклом";

}

Чтобы материал стал более понятным рассмотрим еще такой пример:

/*Программа выводит на экран данные таблицы умножения на 2*/

#include < iostream.h >

void main()

{

int i = 0;

cout << "Таблица умножения на 2 \n";

while ( i ++ < 10)

cout << i << " * 2 = " << i * 2 << '\n';

cout << "\n Все";

}

Давайте остановимся на операторе while в данном примере и по шагам посмотрим, как он работает.

while ( i ++ < 10)

cout << i << " * 2 = " << i * 2 << '\n';

Цикл состоит из двух частей: условие цикла и тело цикла. Обратите внимание на условие цикла - это выражение i++ < 10 . Условие гласит, что тело цикла будет выполняться пока выполняется условие i < 10 . ПОСЛЕ проверки этого условия значение переменной i увеличивается на 1 (об этом говорит оператор i++). Тело цикла состоит всего из одного оператора, а именно:

cout << i << " * 2 = " << i * 2 << '\n';

Итак, 1-й шаг цикла

1.1 Значение переменной i равно 0 (так она была проинициализирована).

1.2 Проверка условия i < 10 дает истина (т.к. 0 < 10)

1.3 Значение переменной i увеличивается на 1, теперь i = 1.

1.4 Так как проверка условия цикла дала значение истина управление

передается оператору тела цикла, т.е. на экран выводится строка 1 * 2 = 2

1.5 Далее управление передается циклу while

2-й шаг цикла

2.1 Значение переменной i равно 1.

2.2 Результат проверки условия цикла - истина (1 < 10)

2.3 Значение переменной i увеличивается на 1, теперь i = 2.

2.4 Так как проверка условия цикла дала значение истина управление

передается оператору тела цикла, т.е. на экран выводится строка 2 * 2 = 4

2.5 Далее управление передается циклу while

. . .

9-й шаг цикла

9.1 Значение переменной i равно 8.

9.2 Результат проверки условия цикла - истина (8 < 10)

9.3 Значение переменной i увеличивается на 1, теперь i = 9.

9.4 Так проверка условия цикла дала значение истина управление

передается оператору тела цикла, т.е. на экран выводится строка 9 * 2 = 18

9.5 Далее управление передается циклу while

10-й шаг цикла

10.1 Значение переменной i равно 9.

10.2 Результат проверки условия цикла - истина ( 9 < 10)

10.3 Значение переменной i увеличивается на 1, теперь i = 10.

10.4 Так проверка условия цикла дала значение истина управление

передается оператору тела цикла, т.е. на экран выводится строка 10 * 2 = 20

10.5 Далее управление передается циклу while

11-й шаг цикла

11.1 Значение переменной i равно 10.

11.2 Результат проверки условия цикла - ложь ( 10 равно 10, а не меньше!)

11.3 Значение переменной i увеличивается на 1, теперь i = 11.

11.4 Так проверка условия цикла дала значение ложь, управление

НЕ передается в тело цикла, т.е. выполнение цикла заканчивается,

и управление переходит к оператору, следующему за while,

т.е. к cout << "\n Все";

Цикл do—while

Этот цикл имеет такой вид:

do оператор while (условие продолжения);

Здесь сначала выполняется оператор, а затем производится проверка условия_продолжения. Если условие истинно, управление возвращается в начало цикла; если ложно, цикл завершается и управление переходит к оператору, следующему за циклом.

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

7.Операторы С++.

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

(if ( выражение ) оператор

if ( выражение ) оператор else оператор)

Оператор whilе

Оператор dо

Оператор for

Оператор switch

Оператор break

Оператор contiпие

Оператор returп

Оператор gotо

Оператор deletе

?Унитарные операторы и бинарные операторы.

Оператор '+=' всегда бинарный

Оператор '++' всегда унарный

Бинарный оператор можно определить либо в виде нестатической функции-члена с одним аргументом, либо в виде функции-не-члена с двумя аргументами. Для любого бинарного оператора @ выражение aa@bb интерпретируется либо как aa .operator@(bb), либо operator@(aa, bb). Если определены обе функции, то для выяснения того, какую (возможно никакую) из них использовать, применяется механизм разрешения перегрузки. Например:

class X

{

public:

void operator+(int);

X(int);

};

void operator+(X, X);

void operator+(X, double);

void f(X a)

{

a+1; // a .operator+(1)

1+a; // ::operator+(X(1), a)

a+1.0; // ::operator+(a, 1.0)

}

Для встроенных типов четыре предопределенных оператора ("+", "-", "*" и "&") используются либо как унарные, либо как бинарные.

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

Логические операторы,

УСЛОВИЕМ может быть любое логическое выражение или переменная типа bool

Логические операторы:

&& И A && B верно, если верно A и верно B

|| ИЛИ A || B верно, если верно либо A либо B

! НЕ !A верно, если А – неверно

операторы сравнения,

Операторы сравнения:

>  Больше a>b

<  Меньше a<b

>= Больше или равно a>=b

<= Меньше или равно a<=b

== Равно a==b

!= Не равно a!=b

оператор присваивания,

Операция присваивания в языке программирования C++ обозначается знаком '='

a=b;

a=5;

операторы инкремента и декремента.

=	Присваивание	a=b
++	Инкремент	a++ ++a
--	Декремент	a-- --a
+=	Сложение	a+=b
-=	Вычитание	a-=b
*=	Умножение	a*=b
/=	Деление	a/=b
%=	Остаток	a%=b
>>=	Сдвиг вправо	a>>=b
<<=	Сдвиг влево	a<<=b
&=	И	a&=b
|=	Или	a|=b
^=	Исключающее или	a^=b

Есть различия в том,справа или слева стоит сам знак. Разницы я пока что не нашел.

Операторы break,continue,return.

\ 1.4.6. Оператор break

Оператор break обеспечивает прекращение выполнения самого внутреннего из объединяющих его операторов switch, do, for, while. После выполнения оператора break управление передается оператору, следующему за прерванным.

Операторы break используются только внутри циклов.

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

Оператор continue завершает текущую итерацию цикла, осуществляя переход к концу тела цикла. Например:

flag := False; for var i:=1 to 10 do begin   read(x);   if x<0 then continue; // пропуск текущей итерации цикла   if x=5 then   begin     flag := True;     break; // выход из цикла   end;  end;

Использование операторов break и continue вне тела цикла ошибочно.

Оператор exit предназначен для досрочного завершения процедуры или функции. Например

function Analyze(x: integer): boolean; begin   if x<0 then   begin     Result := False;     exit   end;   ... end;

Вызов exit в разделе операторов основной программы приводит к ее немедленному завершению.

Следует отметить, что в PascalABC.NET (в отличие от Borland Pascal и Borland Delphi) break, continue и exit являются не процедурами, а именно операторами.

Часто при вознекновении некоторого события удобно иметь возможность досрочно завершить цикл. Используемый для этой цели оператор break (разрыв) вызывает немедленный выход из циклов, организуемых с помощью операторов for, while, do-while, а также прекращение оператора switch. Приведенная ниже программа обеспечивает поиск в заданном иассиве элемента, равного g (пример 4.9). В случае обнаружения такого элемента оператор break прекращает дальнейшее выполнение цикла. Так как параметр i сохраняет значение после выхода из цикла, то дальнейший анализ его значения (if(i==n)) позволяет судить об удачном (i<=n)  илинеудачном (i==n) поиске. В случае вложенных циклов оператор break немедленно прекращает выполнение самого внутреннего из объемлющих его циклов.

  Пример 4.9

/*линейный поиск*/ #include <stdio.h> int a[]={1,2,3,33,5,6,0,8}; int n=8; main() { int i,g=33; for(i=0;i<n;i++) if(a[i]==g) break; if(i==n) printf("%d не найден\n",g); else printf("%d на %d месте \n"g,i); }

На примере 5.0 приведена программа, которая ведет подсчет числа различных элементов в массиве. Каждый очередной элемент a[i] сравнивается с последующими элементами массива. Если он не совпадает ни с одним из этих элементов, в счетчик k добавляется еденица. В противном случае внутренний цикл прерывается оператором break и начинается новая итерация внешнего цикла.

         Пример 5.0

/*число разных элементов*/ #include <stdio.h> main() { static a[]={7,3,7,4,3,6}; int i,j,m,k=1;m=6; for(i=0;i<m-1;i++) {   for(j=i+1;j<m;j++) if(a[i]==a[j]) break; if(j==m) k++; } printf("%d разных элем. \n", k); }

Оператор continue тоже предназначен для прерывания циклического процесса, организуемого операторами for, while, do-while. Но в отличае от оператора break, он не прекращает дальнейшее выполнение цикла, а только немедленно переходит к следующей интерации того цикла, в теле которого он оказался. Он как бы имитирует безусловный переход на конечный оператор цикла, но не за ее пределы самого цикла. Программа на примере 5.1 использует оператор continue для пропуска отрицательных элементов массива, суммируя только положительные.

Оператор continue используются только внутри циклов.

            Пример 5.1

#include <stdio.h> main() { static int a[]={1,2,-3,4,-5,6}; int i,n,s; n=6; s=0; for(i=0; i<n; i++) { if(a[i]<=0) continue; /*пропуск 0*/       s+=a[i];      } printf("сумма = %d \n",s); }

! Операторы break и continue применяются ТОЛЬКО в циклах while и for

cout << "Символы латинского алфавита:\n" << endl;

for(int ch = 0; ; ch++){

if(ch>255) break;

if(ch>'z' || ch<'a‘) continue;

cout << "ASCII код: " << ch <<" \tсимвол "<< (char)ch << endl;

}

Оператор return

Оператор return завершает выполнение функции, в которой он задан, и возвращает управление в вызывающую функцию, в точку, непосредственно следующую за вызовом. Функция main передает управление операционной системе. Формат оператора:

return [выражение] ;

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

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

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

Пример:

int sum (int a, int b) { renurn (a+b); }

Функция sum имеет два формальных параметра a и b типа int, и возвращает значение типа int, о чем говорит описатель, стоящий перед именем функции. Возвращаемое оператором return значение равно сумме фактических параметров.

Пример:

void prov (int a, double b) { double c; if (a<3) return; else if (b>10) return; else { c=a+b; if ((2*c-b)==11) return; } }

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

Оператор returп

Возврат из функции в вызывающую программу осуществляется с помощью оператора return, имеющего один из двух видов:

return ;

return выражение ;

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

8.Функции.

Функция – это изолированный блок кода, имеющий определенное специфическое название.

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

Каждая функция, вызываемая в программе, должна быть где-то определена (только один раз).

Прототипы функций,

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

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

Пример объявления прототипа:

//Объявление прототипа функции Sqr

double Sqr (double);

int main ( )

{

cout << " 5 в квадрате = " < return 0;

}

double sqr (double z)

{ return z*z;}

определение функций,

#include <windows.h>

#include <iostream>

using namespace std;

double my_pow(double, int); // Описание функции

int main(){

SetConsoleOutputCP(1251);// Для отображения русских символов

double Val;

int N;

cout << "Val = ";

cin >> Val;

cout << "N = ";

cin >> N;

cout << Val << " в степени " << N << " равно " << my_pow(Val,N) << endl;

return 0;

}

double my_pow(double Val, int N){// Определение функции

double Ret = 1;

for(int i=0; i<N; i++) Ret *= Val;

return Ret;

}

Непонятно-требуется разделить последующую информацию на группы:

В практике программирования часто встречается ситуация, когда одну и ту же группу операторов, реализующих определённую цель, требуется повторить без изменений в нескольких других листах программы. Чтобы избавить программиста от столь иррационального занятия, была предложена концепция подпрограммы. Подпрограммой называется именованная логически законченная группа операторов языка, которую можно вызвать для выполнения по имени любое ко-личество раз из различных мест программы. В языке СИ++ все подпрограммы являются функциями. Объявления и определения функций. < возвращаемый тип > < имя функции > (<список типизированных параметров>) {            < тело функции > }                               Примеры: double sqr (double y)          { return 0 y*y } char prevChar (char c)          { return c-1;          } Правила объявления и определения функций в СИ++. 1) При объявлении функции перед её именем всегда указывается тип возвращае-мого ею значения. 2) Если  список  параметров  пуст, круглые  скобки  после  имени функции долж-ны быть указаны. СИ++ позволяет вам использовать ключевое слово void для яв-ного указания того, что список параметров пуст, хотя это будет возвратом к стан-дартному языку СИ. 3) Список параметров с указанием типов должен иметь следующий вид:  [const ] < тип1><параметр1>, [const ] тип2 параметр2,... Параметры задаются подобно тому, как определяются переменные: сначала задается тип параметра, а потом идентификатор параметра. В  С++ параметры в списке разделяются запятыми. Для каждого параметра необходимо указать его тип. Ключевое слово const объявляет компилятору, что значение параметра не должно изменяться функцией. 4) Тело функции C++ заключается в фигурные скобки. За закрывающейся скобкой не должно быть точки с запятой. 5) C++ поддерживает передачу параметров, как по ссылке, так и по значению. По умолчанию параметры передаются по значению. В этом случае функция работает с копией передаваемых данных, оставляя оригинал данных неизменным. Для оп-ределения параметра передающегося по ссылке, необходимо после указания типа ввести символ &. Имя ссылочного параметра является псевдонимом фактического параметра. Любое изменение ссылочного параметра влечет за собой изменение переменной переданной в качестве фактического параметра. Общая форма задания ссылочных параметров: [const] <тип 1&><параметр 1>, [const]<тип 2&>параметр 2>... Ключевое слово const объявляет компилятору, что значение параметра не должно быть изменено функцией. 6) C++ поддерживает локальные константы и локальные данные различных типов. Все эти элементы могут быть объявлены во вложенных блоках операторов, однако C++ не поддерживает вложенных функций. 7) Ключевое слово return передает в вызывающую функцию возвращаемое значе-ние, если оно существует. 8) Если тип возвращаемого функцией значения - void, вы не обязаны использовать оператор return, кроме того случая, когда нужно произвести выход из функции прежде, чем она выполнится целиком. В этом случае оператор return не имеет па-раметра, - ничего возвращать не нужно. С++ требует, чтобы либо объявление, либо определение функции предше-ствовали её вызову. Объявление функции называется прототипом, содержит имя функции, тип возвращаемого функцией значения и количество, и тип её парамет-ров. Указание имён параметров не является обязательным. За списком парамет-ров, после закрывающейся скобки, должна следовать ;, а не операторный блок. С++ требует, чтобы функция была объявлена, до того как она будет полностью определена, если вызов её предшествует её определению. Пример объявления прототипа:   //Объявление прототипа функции Sqr     double Sqr (double);     int main ( )     {       cout << " 5 в квадрате = " <      return 0;      }      double sqr (double z)      { return z*z;} Обычно объявленная функция является глобальной, т.е. она доступна всем другим функциям. Если объявить прототип функции в той, из которой она вызы-вается, то прототип будет скрыт от других функций. При вызове функции необходимо поставить в соответствие параметрам пе-редаваемые аргументы. Соответствие аргументов параметрам устанавливается в том порядке, в котором были объявлены. Тип аргументов должен совпадать или быть совместимым с типом параметров. Пример:     double volume(double length, double width, double height)     {      return length*width*height;      }      double len=34, wiadth=55, let=100;      int i=3;      long j=44;      unsigneg k=33; cout << volume (len, width, ht) << endl; cout << volume (1, 2, 3) << endl; cout << volume (i, j, k) << endl cout << volume (len, j, 22.3) << endl;

использование библиотечных функций.

Стандартная библиотека

Обработка символов <ctype.h>

Математические функции <math.h>

Ввод-вывод <stdio.h>

Функции общего назначения <stdlib.h>

Обработка строк <string.h>

Функции даты и времени <time.h>

…

Встраиваемые(inline) функции.

Использование ключевого слова inline

При объявлении функции внутри программы C++ позволяет вам предварить имя функции ключевым словом inline. Если компилятор C++ встречает ключевое слово inline, он помещает в выполнимый файл (машинный язык) операторы этой функции в месте каждого ее вызова. Таким образом, можно улучшить читаемость ваших программ на C++, используя функции, и в то же время увеличить производительность, избегая издержек на вызов функций. Следующая программа INLINE.CPP определяет функции тах и min как inline:

#include <iostream.h>

inline int max(int a, int b)

{    if (a > b) return(a);    else return(b) ; }

inline int min(int a, int b)

{    if (a < b) return(a);    else return(b); }

void main(void)

{    cout << "Минимум из 1001 и 2002 равен " << min(1001, 2002) << endl;    cout << "Максимум из 1001 и 2002 равен " << max(1001, 2002) << endl; }

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

О встроенных функциях

Если компилятор C++ перед определением функции встречает ключевое слово inline, он будет заменять обращения к этой функции (вызовы) на последовательность операторов, эквивалентную выполнению функции. Таким образом ваши программы улучшают производительность, избавляясь от издержек на вызов функции и в то же время выигрывая в стиле программы, благодаря использованию функций.

Встроенные функции

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

#include <iostream.b>

void show_message(int count, char *message)

{    int i;    for (i = 0; i < count; i++) cout << '\a';    cout << message << endl; }

void main(void)

{    show_message(3, "Учимся программировать на языке C++");    show_mes sage(2, "Урок 35"); }

Следующая программа NO_CALL.CPP не вызывает функцию show_message. Вместо этого она помещает внутри себя те же операторы функции при каждой ссылке на функцию:

#include <iostream.h>

void main (void)

{    int i;    for (i = 0; i < 3; i++) cout << '\a';    cout << " Учимся программировать на языке C++" << endl;    for (i = 0; i < 2; i++) cout << '\a';    cout << "Урок 35" << endl; }

Обе программы выполняют одно и то же. Поскольку программа NO_CALL не вызывает функцию show_message, она выполняется немного быстрее, чем программа CALLBEEP. В данном случае разницу во времени выполнения определить невозможно, но, если в обычной ситуации функция будет вызываться 1000 раз, вы, вероятно, заметите небольшое увеличение производительности. Однако программа NO_CALL более запутана, чем ее двойник CALL_BEEP, следовательно, более тяжела для восприятия.

При создании программ вы всегда должны попытаться определить, когда лучше использовать обычные функции, а когда лучше воспользоваться встроенными функциями. Для более простых программ предпочтительно использовать обычные функции. Однако, если вы создаете программу, для которой производительность имеет первостепенное значение, вам следовало бы уменьшить количество вызовов функций. Один из способов уменьшения количества вызовов функций состоит в том, чтобы поместить соответствующие операторы прямо в программу, как только что было сделано в программе NO_CALL. Однако, как вы могли убедиться, замена только одной функции внесла значительную путаницу в программу. К счастью, C++ предоставляет ключевое слово inline, которое обеспечивает лучший способ.

Перегрузка функций.

#include <windows.h>

#include <iostream>

using namespace std;

int my_min(int a, int b){

if(a<b) return a;

return b;

}

int my_min(int a, int b, int c){

if(a<=b && a<=c) return a;

if(b<=a && b<=c) return b;

return c;

}

int main(){

SetConsoleOutputCP(1251);// Для отображения русских символов

int a, b, c;

cout << "Введите два целых числа\n";

cin >> a >> b;

cout << "\nМинимум равен " << my_min(a,b) << endl;

cout << "Введите два целых числа\n";

cin >> a >> b >> c;

cout << "\nМинимум равен " << my_min(a,b,c) << endl;

return 0;

}

Перегрузка процедур и функций - возможность использования одноимённых подпрограмм: процедур или функций в языках программирования.

Реализация

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

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

Чтобы исключить ошибку программиста давшему случайно имя подпрограмме, которое уже используется, вводится дополнительное требование написания ключевого слова. Так сделано, например в языке Delphi (ключевое слово overload).

9.Рекурсия.