С++
// язык программирования

Структура программы С++

Ò Каждая подпрограмма имеет структуру, подобную функции main();

Ò Каждая программа содержит одну или несколько функций;

Ò Каждая функция содержит 4 основных элемента:

1. тип возвращаемого значения; Int

2. имя функции; main()

3. список параметров, {return 0;} -

заключённый в круглые скобки

4. тело функции

- эта строка значит "вернуть операционной системе в качестве сигнала об успешном завершении программы значение 0 ".

Организация консольного – ввода/вывода данных
( т.е . в режиме чёрного экрана)

#include <iostream>; //директива процессора, предназначена для включения в исходный текст содержимое заголовочного файла, имя которого < iostream > , содержащий описания функций стандартной библиотеки ввода/вывода для работы с клавиатурой и экраном.

using namespace stg; // директива означ.что все определённые ниже имена будут отн-ся к пространству имён std

Int main() //имя функции,кот.не содержит параметров и должна возвращать значение типа Int

{Int a,b; //объявление двух переменных типа Int - целый тип

cout <<”введите два целых числа”<<endl; // оператор вывода данных на экран ,

<< - операция помещения данных в выходной поток;

endl - манипулятор, переводит сообщение на новую сточку.

cin >>a >>b; //оператор ввода данных с клавиатуры,

>> - операция для извлечения данных из выходного потока, читает значения из cin и сохр. их в переменных.

cout >>”их сумма равна”<<a+b; //оператор вывода

return 0;} //оператор вывода

Стандартные типы данных

Ò Целые типы данных – short, int, long и спецификаторы ( signed,unsigned);

Ò Вещественные типы – float, double, long double;

Ò Cсимвольные типы – char, wchar_t;

Ò Логический тип – bool , принимающий значения (true-истина, false-ложь);

Константы (const)

a=b+2,5 //неименованная константа;

‘ 1 L’ - целочисленный литерал (тип long);

“8” – целочисл.литерал (тип Int);

‘f’ , – символьный литерал, ‘\n’ - конец строки

Формат описания именованной константы:

[<класс памяти>]const <тип> <имя именован-ой константы>=<выражение>;

const int l= - 124;

const floak k1=2,345, k=1/k1

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

Выражение , определяет значение именованной константы, т.е инициализирует её.

Переменные

Формат описания переменных:

[< класс памяти >]< тип >< имя >[=< выражение > | (< выражение >)];

Пример :

int I,j;

double x;

Значение переменных должно быть определено с помощью:

1. оператора присваивания: int a; // описание переменной

int= a; // опред.значения.переменной

2. оператора ввода: int a; // описание переменной

cin>>a; // опред.знач.переменной

3. инициализация – опред.значения переменной на этом этапе описания.

int i=100 // инициализация копией

int i (100); // прямая инициализация

Управление форматом вещественных типов данных

Сущ.три аспекта оформления значения с плавающей запятой которыми можно управлять:

- точность ( кол-во отображаемых цифр), изменяется с помощью манипулятора setprecisio n;

- форма записи (десятичная или экспонец-ая);

- указание десятичной точки для значения с пл.запятой, являющихся целыми числами .

- #include <iostream> Результат работы программы:

- #include <iomanip> 1.23e+004

- using namespace std; 12345.7

- int main() 12345.6789

- { double i=12345,6789;

- cout << setprecision(3)<<i<<endl;

- cout << setprecision(6)<<i<<endl;

- cout << setprecision(9)<<i<<endl;

- refurn 0;}

- (для использования манипуляторов endl с аргументами требуется подключить заголовочный файл iomanip )

Управление размещение данных на экране

Ò Используются манипуляторы :

1. lief – выравнивает вывод по левому краю;

2. right – выравнивает вывод по правому краю;

3. internal – контролирует размещение отрицательного значения: выравнивает знак по левому краю, а значение по правому, заполняя пространство между ними пробелами;

4. setprecision(int w) – устанавливает max кол-во цифр в дробной части для вещественных чисел;

5. setw(int w) – устанавливает max ширину поля вывода;

Пример: Получим:

#include <iostream> 1. Ivanov;

#include <iomanip> 2.Ivanov;

using nanespace std; 3. Ivanov;

int main()

{ cout <<“1” <<setw(10) <<“Ivanov” <<endl;

cout <<“2” <<setw(10) <<lief<<“Ivanov” <<endl;

cout <<“3” <<setw(10) <<right<<“Ivanov” <<endl;

return 0;}

Задание

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

Должно получиться: 1. -23,4567

2. -23,5

3. - 23,5

Операции. Унарные операции

Ò Операции увеличения (декремента) и уменьшения (инкремента)

на 1(++ и --) ; записываются в двух формах:

Префикси я – операция записывается перед операндом и увеличивает свой операнд на 1 и возвращает изменённоё значений как результат

Постфиксия – операция записывается после операндом, уменьшает свой операнд на 1 и возвр.изменённое знач.как результат.

Пример:

#include <iosteram>

int main()

using nanespace std;

{ int x=3, y=4;

cout <<++x<<“\t”<<--y<<endl;

cout <<x++<<“\t”<<y--<<endl;

cout <<x<<“\t”<<y<<endl;

return 0;}

Операции отрицания (-,!)

Ò (-) - унарный минус – изменяет знак операнда целого или вещественного типа на противоположный;

Ò (!) – логическое отрицание , даёт в результате значение 0(ложь), если операнд отличен от 0(истина),если равен операнд 0 (ложь);

Ò тип оп e ранда может быть любой.

Пример:

#include <iosteram>

int main()

using nanespace std;

{ int x=3, y=0;

bool f=false, v=true;

cout <<-x<<“\t”<<!y<<endl;

cout <<-y<<“\t”<<!y<<endl;

cout <<v<<“\t”<<!v<<endl;

return 0;}

Бинарные операции

Ò Арифметические операции : умножение .(*), деление .(/), остаток от деления . (%); слож .(+), вычит .(-)

Рассмотрим операции деления и остаток от деления:

#include <iosteram>

using nanespace std;

int main()

{ cout <<100/24<<“\t”<<100/24<<endl;

cout <<100/21<<“\t”<<100,0/24<<endl;

cout <<21%3<<“\t”<<21%6<<“-21%8”<<endl;

return 0;}

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

- Операции отношения: ( <, <=, >, >=, == !=) , меньше, меньше или равно, больше, больше или равно, равно, не равно, не равно соответственно).

Результатом операций являются значения true, false .

Логические операции ( && и ||)

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

ИЛИ || - возвращает знач.истина тогда и.т.тогда, когда хотя бы один операнд принимает значение истина, в противном случае –ложь

- логические операции выполняются слева направо;

- приоритет операции && выше ||.

Пример:

#include <iosteram>

using namespace std;

int main()

{ cout <<‘x\t y\t &&\t||’endl;

cout <<“0\t 1\t”<<(0 && 1)<<‘\t’<<(0||1)endl;

cout <<‘0\t 1\t’<<(0 && 1)<<\t’<< (0||1)endl;

cout <<‘1\t 0\t’<<(1 && 0)<<‘\t’<<(1||0)endl;

cout <<‘1\t 1\t’<<(1 && 1)<<‘\t’<<(1||1)endl;

return 0;}

Операции присваивания

Ò формат операция простого присваивания (=):

Ò опреанд_1 = операнд_2

пример : a=b=c=100, это выражение выполняется справа налево, результатом выполнения с=100, является число 100, которое затем присвоиться переменной b, потом а.

Ò Сложные операции присваивания :

Ò (*=) – умножение с присв-ем,

Ò ( /=) - деление с присв-ем

Ò (%= )- остаток от деления с присв-ем,

Ò (+=) –сложение с присв.,

Ò (-=) - вычит.с присв.

Ò пример : к операнду _1 прибавляется операнд_2 и результат записывается в операнд_2

Ò т.е . с = с + а, тогда компактная запись с += а

Тернарная операция

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

Ò Формат условной операции: операнд_1 ? операнд_2 ? : операнд_3

Ò Операнд_1 это логическое или арифметич-ое выражение;

Ò Оценивается с точки зрения эквивалентности константам true и false;

Ò Если результат вычисления операнда_1 равен true,то результат условной операции будет значение операнда_2, иначе операнда_3;

Ò Тип может различаться;

Ò Условная операция является сокращ. формой услов-го оператора if;

Пример : Результат:

#include <iosteram> для х=11 и y=9

int main() 11

using nanespace std; 11

{ int x, y,max;

cin >>x>>y;

(x>y)? cout <<x: cout<<y<<endl; //1 нахождение наибольшего зна-

max=(x>y)? x:y; //2 чения для двух целых чисел;

cout<<max<<endl;

return 0;}

Ò

Выражения преобразования типов

Ò Примеры :

Ò (a+0,12)/6; x && y || !z;

Ò (t*sin(x)-1,05e4)/((2*k+2)*(2*k+3))4;

Ò операции выполняются в соответствии с приоритетом;

Ò если в одном выражении имеются неск.операций одинаково приоритета, то унарные операции выполняются- справа

Ò налево , остальные –слева направо

Ò Т.е : a= b+c значит a=(b=c),

Ò а + b+c значит (a +b) +c

Ò в выражения могут входить операнды различных типов;

Ò при одинаковом типе операндов, результат будет им.тот же тип;

Ò если разного типа операнды, то операнд с более «низким» типом будет преобразован к более «высокому» типу для сохранения значимости и точности:

Неявное преобразование:

include <iosteram>

using nanespace std;

int main()

{ int a=100, b; float c=4,5, d;

d=a/c; //1- без потери точности

cout << “d=” <<d<<endl;

b=a/c; //2- с потерей точности

cout <<“b=”<<b<<endl; refurn 0;}

Ò Задания:

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

Х² +sin (x+1)/25, c учётом приоритета операций в с++:

(pow(x,2)+sin(x+1)/25;

2.Написать программу, подсчитывающую площадь квадрата, периметр которого равен p.

Пусть дан квадрат со стороны а , тогда: p = 4a , а = p/4……

s=a^{2 …………………………… …..S=}

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

Ò Программа на языке С++ состоит из последовательности операторов, каждый из них определяет значение некоторого действия;

Ò Все операторы разделены на 4 группы:

- операторы следования;

- операторы ветвления;

- операторы цикла;

- операторы передачи управления.

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

Ò К ним отн-ся : оператор выражение и составной оператор.

Ò Выражение , завершающееся точкой с запятой, рассматривается как оператор (вычислении значения выражения или выполнении законченного действия);

++ i ; // оператор инкремента

х+=у ; //оператор сложение с присваиванием

f ( a , b ) //вызов функции

x = max (a , b ) + a * b ; //вычисление сложного выражения

Ò Частным случаем оператора выражения является пустой оператор ;

(используется, когда по синтаксису оператор требуется, а по смыслу — нет)

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

Ò Блок обладает собственной областью видимости: объявленные внутри блока имена доступны только внутри блока;

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

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

Ò К ним отн-ся : условный оператор if и оператор выбора switch ,

они позволяют изменить порядок выполнения операторов в программе_;

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

Ò if используется для разветвления процесса обработки данных на два направления.

Ò if имеет формы: сокращенную или полную.

Ò Формат сокращенного оператора if : if (В) S ;

В –логич. или арифметич. выражение, истинность которого проверяется; S - один оператор: простой или составной.

Ò При выполнении сокращенной формы оператора if сначала вычисляется выражение В, затем проводится анализ его результата: если В истинно, то выполняется оператор S; если В ложно, то оператор S пропускается.

Ò C помощью сокращенной формы оператора If можно либо выполнить оператор S, либо пропустить его.

Ò Формат полного оператора if : if ( B ) S 1 ; else S 2;

SI , S 2- один оператор: простой или составной.

Ò При выполнении полной формы оператора if сначала вычисляется выражение В, затем анализируется его результат: если В истинно, то выполняется оператор S1 а оператор S 2 пропускается; если В ложно, то выполняется оператор S2, a S 1 - пропускается.

Ò C помощью полной формы оператора if можно выбрать одно из двух альтернативных действий процесса обработки данных.

Примеры записи условного оператора if .

Ò if (a > 0) х=у; // сокращенная форма с простым оператором

Ò if (++i) {x=y; y=2*z;} // сокращенная форма с составным оператором

Ò if (а > 0 |'| b<0) x=y; eise x=z; //полная форма с простым оператором

Ò if (i+j-1) { х= 0; у= 1;} else {x=1; у:=0;} //полная форма с составными операт

Ò Операторы S1 и S2 могут являться операторами if , такие операторы наз. вложенные ;

Ò Ключевое слово else связывается с ближайшим предыдущим словом if , которое еще не связано ни с одним else .

Ò Примеры алгоритмов с использованием вложенных условных операторов:

Ò Пример1 Уровни вложенности If Пример 2 Уровни вложенности if

Ò if(A<B) if (A<B)

Ò if (С < D) if (C<D) X=Y 2

Ò if(E<F)X=Q; else X=Z:

Ò else X = R; 3 2 1 else 1

else X=Z; if (E<F) X=R;

else X = Y; else X=Q; 2

Ò Оператор выбора switch

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

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

switch (<выражение>)

{ case <константное_выражение_1>: [<оператор 1>]

case <константное_выражение_2>: [<оператор 2>]

…………………………..

case <константное_выражение_ n >: [<оператор n >]

[ default : <оператор> ]}

Ò Выражение, стоящее за ключевым словом switch , должно иметь арифметич. тип или тип указатель.

Ò Все константные выражения должны иметь разные значения, но совпадать с типом выражения, стоящим после switch.

Ò Ключевое слово case и расположенное после него константное выражение называют также меткой case .

Ò Выполнение оператора начинается с вычисления выражения, расположенного за ключевым словом switch .

Ò Полученный результат сравнивается с меткой case .

Ò Если результат выражения соответствует метке case , то выполняется оператор, стоящий после этой метки.

Ò Затем последовательно выполняются все операторы до конца оператора switch , если только их выполнение не будет прервано с помощью оператора передачи управления break

Ò При использование оператора break происходит выход из switch и управление переходит к первому после него оператору.

Ò Если совпадения выражения ни с одной меткой case не произошло, то выполняется оператор, стоящий после слова default , а при его отсутствии управление передается следующему за switch оператору.

Ò Пример. Известен порядковый номер дня недели. Вывести на экран его название.

#include <iostream>

using namespace std;

int main()

{int x; cin >>x;

switch (x)

{ case 1: cout <<"понедельник"; break;

case 2: cout <<"вторник"; break;

case 3: cout <<"среда"; break;

case 4: cout <<"четверг"; break;

case 5: cout <<"пятница"; break;

case 6: cout <<"суббота"; break;

case7: cout <<"воскресенье";break;

default: cout <<"вы ошиблись";}

return 0;}

Использование операторов ветвления:

Ò Дана точка на плоскости с координатами (х, у).

Ò Составим программу, которая выдает одно из сообщений «Да», «Нет», «На границе» (в зависимости от того, лежит ли точка внутри заштрихованной области, вне заштрихованной области или на ее границе)

Ò Заданная область разбивает всю плоскость на 3 непересекающихся множества точек. y

Ò I₁ -множество точек, лежащих внутри области;

Ò I₂ - множество точек, лежащих вне области;

Ò I₃ - множество точек, образующих границу области. 10 x

-10

Ò Точка с координатами (х, у) может принадлежать только одному из них;

Ò Множества I₁ , I_2, I₃ значительно труднее описать математич-ки, чем интервалы в примере 2,поэтому для проверки выбираются те два множества, которые наиболее просто описать математич-ки.(труднее всего описать точки границы области).

Ò Для рис. 1 множества задаются следующим образом; I ₁ :х² + у² <10² ; I ₂ :х² + у² >10² ;

I ₃ : х² +у² = 10² .

Ò Множества

Ò I ₁ :х² + у² <10² ; I ₂ :х² + у² >10² ;

Ò I ₃ : х² +у² = 10² . рис.1

х

#include < iosfream>

#include <cmath> 10 y

using namespace std;

int main() -10

{ float x,y;

cout << "x="; cin >>x;

cout << “y”; cin >>y;

if (x*x+y*y< 100) //точки внутри области ?

cout <<"Да";

else if (x*x+y*y>100) //точки вне области?

cout<<"HЕT“;

else cout << "на границе";

return 0;}

Результат программы:

Координаты точек ответ

0 да

10 на границе

- 12 нет

Ò Множества задаются (для рисунка 2) :

I₁ : | х |<10 и |y|<5; I₂ : |x| >10 или |y|>5;

I ₃ :( |х | <=10и у = 5) или( |х | <=10и у = -5) или ( | y |<5и x = 10) или( |у|<5и х = -10 ).

Ò рис.2

#include <iostream> y Результат:

#include <cmath> 5 координаты точек ответ

int main() x 0 0 да

cout <<“x=“; cin>>x; 10 10 5 на границе

cout <<"y="; cin>>y; -12 13 нет

If (fabs(x)<10 && fabs(y)<5) //точки внутри области?

cout <<"Да";

else if (fabs(x)>101 || fabs(y)>5) //точки вне области?

cout<<"HeT";

else cout <<"на границе";

return 0;}

Ò

Ò Дан номер фигуры (1- квадрат, 2 - треугольник);

Ò по номеру фигуры запросить необходимые данные для вычисления площади;

Ò прои звести вычисление площади фигуры и вывести получ-ые данные на экран.

#include <iostream>

#include <cmath>

using namespace std;

int main()

{ int x;

cout << “Программа подсчитывает площадь:\n1. квадрата;\n2. треугольника.\nЗ. выход из программы’’;

cout <<“Укажите номер фигуры или завершите работу с программой.\n”;

cin >> x;

switch (x)

{case 1 :{cout <<"введите длину стороны квадрата\n";

float a; cin >>a;

if (a>0) cout«"Площадь квадрата со стороной" <<а <<"равна\t <<а*а;

else cout «"Квадрат не существует\n";

break;}

case 2: {cout« "введите длины сторон треугольника\n";

float a,b,c,p, s; cin >>a >>b >>c;

if (a+b>c && a+c>b && b+c>a)

{p=(a+b+c)/2; s= sqrt(p*(p-a)*(p-b)*(p-c));

cout <<"Площадь треугольника со сторонами" <<a <<b <<c <<"равная\t" <<s;}

else cout<<"Tpeyгольник не существуетет\n";

break;}

Ò case 3:break;

Ò default: cout <<"Номер фигуры указан не верно\n";}

return 0;}

задание

Ò 1. Дана точка на плоскости с координатами (х, у).

Ò Составить программы , которые выдают одно из сообщений:

Ò «Да», «Нет», «На границе» ,

Ò в зависимости от того, лежит ли точка:

- внутри заштрихованной области,

- вне заштрихованной области

- или на ее границе.

Области задаются графически следующим образом:

Ò 2. Дан порядковый номер месяца, вывести на экран его название.

Ò 3. Дан порядковый номер дня недели, вывести на экран количество дней оставшихся до конца недели.

Операторы цикла

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

- цикл с предусловием while,

- цикл с постусловием do while

- цикл с параметром for.

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

Ò Оператор цикла while организует выполнение одного оператора (простого или составного) неизвестное заранее число раз.

Ò Формат цикла while : while (В) S ;

Ò В - выражение, истинность которого проверяется (условие завершения цикла);

Ò S - тело цикла: один оператор (простой или составной).

Ò Перед каждым выполнением тела цикла анализируется значение выражения В:

- если оно истинно, то выполняется тело цикла, и управление передается на повторную проверку условия В;

- если значение В ложно - цикл завершается и управление передается на оператор, следующий за оператором S.

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

- если условие В во время работы цикла не будет изменяться, то возможна ситуация зацикливания, то есть невозможность выхода из цикла.

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

Рассмотрим программу вывода на экран целых чисел из интервала от 1 до n.

Ò #include <iostream>

Ò using namespace std:

Ò int main()

Ò { intn, i=1;

Ò cout <<"n="; cin >>n;

Ò while ( i <= n ) //пока i меньше или равно n Результаты работы программы :

Ò { cout«i«"\t"; //выводим на экран значение i _{n ответ}

Ò ++i;} //увеличиваем i на единицу ₁₀ 12345678910

Ò return 0;}

Ò Замечание: используя операцию постфиксного инкремента, тело цикла можно заменить одной командой cout <<;'++ <<"\t".

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

Ò В отличие от цикла while условие завершения цикла проверяется после выполнения тела цикла.

Ò Формат цикла do while : do S while (В);

В - выражение, истинность которого проверяется (условие завершения цикла);

S - тело цикла: один оператор (простой или блок).

Ò Сначала выполняется оператор S , а затем анализир-ся значение выражения В:

- если оно истинно, то управление передается оператору S ,

- если ложно - цикл заверш. и управление передается на оператор, следующий за условием В.

Пример( do while ): программа вывода на экран целых чисел из интервала от 1 до п.

Ò #include <iostream>

Ò using namespace std;

Ò int main()

Ò {intn, i=1;

Ò cout <<"n="; cin >>n;

Ò do //выводим на экран i , а замет увеличиваем Результаты работы программы:

Ò с out<<i ++ << "\ t "; //ее значении на единицу n _ответ

Ò whiie ( i <= n ); //до тех пор пока i меньше или равна n 10 1 2 3 4 5 6 7 8 9 10

Ò return 0;}

Цикл с параметром for

Ò Цикл с параметром имеет следующую структуру:

Ò for (<инициализация>; < выражение>; <модификации>) <оператор>;

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

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

Ò Выражение определяет условие выполнения цикла:

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

Ò Истинность выражения проверяется перед каждым выполнением тела цикла, таким образом, цикл с параметром реализован как цикл с предусловием.

Ò Модификации выполняются после каждой итерации цикла и служат обычно для изменения параметров цикла.

Ò В части модификаций можно записать несколько операторов через запятую.

Ò Оператор (простой или составной) представляет собой тело цикла.

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

Ò #include <iostream>

Ò using namespace std;

Ò int main()

Ò { intn; cout <<"n="; cin >>n; Результаты работы программы :

Ò for (int i=1; j<=n; i++) // для i om 1 д o n с шагом 1 _n ответ

Ò cout<<i<<"\t"; //выводить на экран значение i 1 0 123456789 10

Ò return 0;}

Ò Замечание . Используя операцию постфиксного инкремента при выводе данных на экран, цикл for можно преобразовать следующим образом:

Ò for ( int i=l ;i <= n ;) cout<<i + + << "\ t ";

Ò В этом случае в заголовке цикла for отсутствует блок модификации.

Вложенные циклы

Ò Циклы могут быть простые или вложенные (кратные, циклы в цикле).

Ò Вложенными могут быть циклы любых типов: while , do while , for .

Ò Структура вложенных циклов на примере типа for приведена ниже:

for(i=1;i<ik;i++)

{…

for (j=10; j>jk;j- -)

{...for(k=1;k<kk;j+=2){...} 3 2 1

...}

...}

Каждый внутренний цикл должен быть полностью вложен во все внешние циклы.

--- «Пересечения» циклов не допускается.

Ò Рассмотрим пример использования вложенных циклов, который позволит вывести на экран следующую таблицу:

Ò 2 2 2 2 2 #include <iostream>

Ò 2 2 2 2 2 using namespace std;

Ò 2 2 2 2 2 int main()

Ò 2 2 2 2 2 { for (int i=1; i<=4;++i,cout<<endI) // внешний цикл

for (int j= 1; j<=5; ++]) //внутренний цикл

cout<<"2\t"; //тело внутреннего цикла

return 0;}

Ò Внешний цикл определяет количество строк, выводимых на экран. В блоке модификации данного цикла стоят два оператора.

Ò Первый ++/ будет увеличивать значение i на единицу после каждого выполнения внутреннего цикла, а второй -cout <<endl будет переводить выходной поток на новую строку.

Ò Внутренний цикл является телом внешнего цикла.

Ò Внутренний цикл определяет, сколько чисел нужно вывести в каждой строке, а в теле внутреннего цикла выводится нужное число.

Ò Рассмотрим еще один пример использования вложенных циклов, который позволит вывести на экран следующую таблицу:

#include <iostream>

1 3 using namespace std;

1 3 5 int main()

1 3 5 7 { for (int i=1; i<=5; ++i, cout<<endl) // внешний цикл

1 3 5 7 9 for(int j=1;j<=2*i-1;j+=2) //внутренний цикл

cout<<j<<"\t"; //тело внутреннего цикла

return 0;}

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

Ò Последнее нечетное число в строчке зависит от ее номера.

Ò Эта зависимость выражается через формулу k = 2 i - l (зависимость проверить самостоятельно), где к - последнее число в строке, ;i - номер текущей строки. Внешний цикл следит за номером текущей строки i а внутренний цикл будет печатать нечетные числа из диапазона от 1 до 2 i - I .

задание

Ò Вывести на экран числа в виде следующих таблиц:

Ò 1.) 2.)

5 5 5 5 5 5 5

5 5 5 5 5 5 5 5

5 5 5 5 5 5 5 5 5

5 5 5 5 5 5 5 5 5 5

5 5 5 5 5

Использование операторов цикла

Программу, которая выводит на экран квадраты всех целых чисел от А до В

(А и В целые числа, при этом А<В).

Ò Необходимо перебрать все целые числа из интервала от А до В.

Ò Эти числа представляют собой упорядоченную последовательность, в которой каждое число отличается от предыдущего на 1.

#include <iostream> #include <iostream>

using namespace std; using namespace std;

int main() int main()

{ int a, b; { int a, b;

cout <<"a="; cin >>a; cout <<"a="; cin >>a;

cout <<’’b-’’; cin >>b; cout <<"b="; cin >>b;

int i=a; int i=a;

while (i<=b) do cout<<i*i++<<"\t";

cout<<i*i++<<"\t";. while (i<=b);

return 0;} return 0;}

Ò Выражение i * i ++ (значение которого выводится на экран в теле каждого из циклов)

Ò С учетом приоритета в начале выполнится опрац.умножение, результат которой будет помещен в выходной поток, а затем постфиксный инкремент увеличит значение i на 1.

задание

Ò Написать программу, которая выводит на экран квадраты всех четных чисел из диапазона от А до В (А и В целые числа, при этом А<В).

Ò (решить можно с помощью любого оператора цикла);

Операторы безусловного перехода

Ò В C++ есть четыре оператора, изменяющие естественный порядок выполнения операторов:

Ò оператор безусловного перехода goto ,

Ò оператор выхода break ,

Ò оператор перехода к следующей итерации цикла continue ,

Ò оператор возврата из функции return .

Оператор безусловного перехода goto

Ò Оператор безусловного перехода goto имеет формат: goto <метка>;

Ò В теле той же функции должна присутствовать ровно одна конструкция вида:

Ò <метка>: <оператор>;

Ò Оператор goto передает управление на помеченный меткой оператор

Ò пример использования оператора goto :

Ò #indude <iostream>
using namespace std;
int main()
{float x;
metka: cout <<"x="; //оператор, помеченный меткой

Ò cin»x;

Ò if (x) cout<<“y=“<<1/x<<endl;

Ò else { соut<<"функция не определена\n";

Ò goto metka;} // передача управление метке

Ò return 0;}

Ò - при попытке ввести 0 на экран будет выведено сообщение «функция не определена», после чего управление будет передано оператору, помеченному меткой, и программа повторно попросит ввести значение х.

Ò использование оператора goto затрудняет чтение больших по объему программ, поэтому использовать метки нужно только в крайних случаях.

Оператор выхода break

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

Ò Оператор break применяется также для выхода из оператора switch , аналогичным образом он может применяться для выхода из других операторов.

Оператор перехода к следующей итерации цикла continue

Ò Оператор перехода к следующей итерации цикла continue пропускает все операторы, оставшиеся до конца тела цикла, и передает управление на начало следующей итерации (повторение тела цикла).

Ò Рассмотрим оператор continue на примере:

Ò #include <iostream>

Ò using namespace std;

Ò int main()

Ò { for (int i=1; i<100; ++i) //перебираем все числа от 1 до 99
{if (i % 2) continue; //если число нечетное, то переходим к следующей итерации cout<<i<<"\t";} //выводим число на экран

Ò return 0;}

Ò В результате данной программы на экран будут выведены только четные числа из интервала от 1 до 100, т.к. для нечётныx чисел текущая итерация цикла прерывалась и команда cout<<i<< "\ t " не выполнялась.

Ò Оператор возврата из функции return :

Ò Оператор возврата из функции return завершает выполнение функции и передает управление в точку ее вызова.

Массивы. Указатели.

Ò Когда компилятор обрабатывает оператор определения переменной,

Ò например, int а =50; , то он выделяет память в соответствии с типом int и записывает в нее значение 50)

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

Ò В C++ различают три вида указателей:

Ò - указатели на объект,

Ò - на функцию и на void ;

Ò Указатель на объект содержит адрес области памяти, в которой хранятся

Ò данные определенного типа (простого или составного).

Ò Объявление указателя на объект имеет следующий вид:

<базовый тип > [<модификатор>] * <имя указателям

Ò базовый тип — имя типа переменной, адрес которой будет содержать переменная указатель;

Ò модификатор необязателен., может иметь значение: near , far или huge

Ò Указатель может быть переменной или константой, указывать на переменную или константу, а также быть указателем на указатель.

Ò Например:

Ò int i; //целочисленная переменная

Ò const int j=10; //целочисленная константа

Ò int *a; //указатель на целочисленное значение

Ò int **x; //указатель на указатель на целочисленное значение

Ò const int *b; //указатель на целочисленную константу

Ò int * const c=&i; //указатель-константа на целочисленную переменную

Ò const int 'const d=&j; //указатель константа на целую переменную

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

Ò адрес которого нужно хранить, не определен.

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

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

Ò Существуют следующие способы инициализации указателя:

Ò 1) присваивание указателю адреса существующего объекта:

Ò с помощью операции получения адреса:

Ò int а=50; //целая переменная

Ò int *x=&a; //указателю присваивается адрес целой переменной а

Ò int *y (&а); // указателю присваивается адрес целой переменной а

Ò с помощью значения другого инициализированного указателя

Ò int *z=x; //указателю присваивается адрес, хранящийся в х:

Ò с помощью имени массива или функции (рассмотрим позже).

Ò 2) присваивание указателю адреса области памяти в явном виде:

Ò int *p=(int *) 0xB8000000;

Ò где 0хВ8000000 - шестнадцатеричная константа, ( int *) - операция явного приведения типа к типу указатель на целочисленное значение.

Ò 3) присваивание пустого значения:

Ò int *x=NULL; int *y=0;

Ò где NULL стандартная константа, определенная как указатель равный О

Ò 4) выделение участка динамической памяти и присваивание ее адреса указателю:

Ò int *a = new int; //1

Ò int *b = new int (50); //2

Ò 4) выделение участка динамической памяти и присваивание ее адреса указателю:

Ò int *a = new int; //1

Ò int *b = new int (50); //2

Ò // 1 операция new выполняет выделение достаточного для размещения величины типа int участка динамической памяти и записывает адрес начала этого участка в переменную а.

Ò Память под переменную а выделяется на этапе компиляции.

Ò //2, кроме действий описанных выше, производится инициализация выделенной динамической памяти значением 50.

Ò Освобождение памяти, выделенной с помощью операции new , должно выполняться с помощью операции delete .

Ò При этом переменная-указатель сохраняется и может инициализир-ся повторно.

Ò пример использования операции delete :

Ò delete a; delete []b;

ссылки

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

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

Ò Формат объявления ссылки: <базовый тип> & <имя ссылки>

Например:
int а; //целочисленная переменная

Ò int &b=a; //ссылка на целочисленную переменную а

Следующий пример:

Ò #include <iostream>

Ò using namespace std;

Ò int main()

Ò {int a=50; //целочисленная переменная а

Ò int &b=a; //ссылка b - альтернативное имя для переменной а

Ò cout <<"a\t b\n";

Ò cout «a <<"\t" «b«endl;

Ò a++; //1

Ò cout «a <<"\t" «=b«endl;

Ò b++; //2

Ò cout «a <<"\t" «b«endl;

Ò return 0;}

Одномерный массив

Ò Одномерный массив - это фиксированное количество элементов одного и того же типа, объединенных общим именем, где каждый элемент имеет свой номер.

Ò Нумерация элементов массива в C++ начинается с нулевого элемента, то есть, если массив состоит из 10 элементов, то его элементы будут иметь следующие номера: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9.

Ò Элементы массива могут быть любого типа, в том числе и структурированного (кроме файлового).

Ò Между указателями и массивами существует взаимосвязь: любое действие над элементами массивов, которое достигается индексированием, может быть выполнено и с помощью указателей.

Ò Вариант программы с указателями будет работать быстрее.

Ò Дан массив из 10 целых чисел. Написать программу, которая заменяет в данном массиве все отрицательные элементы нулями.

#include <iostream>

using namespace std;

int main()

{ int n; cout<<"n="; cin>>n; //ввели количество элементов массива

int a[n]; // объявляем статический массив размерностью n

for (int i=0;i<n; ++i) //ввод и обработка данных

{cout<<"a[“<<i<<"]="; cin>>a[ij); //ввод очередного элемента

if (a[i]<0) a[i]=0;} //если i -тый элемент массива отрицат . , то заменяем его на 0

for (int i=0;i<10;++i) cout<<a[i]<<"M"; //вывод массива на экран

return 0;}

Ò Результат работы программы: Исходные данные Ответ

2 -4 1 2 -2 0 23 -12 1 -1 2 0 1 2 0 0 23 0 1 О

Ò Дан массив из n действительных чисел (n<100).

Ò Написать программу для подсчета суммы этих чисел.

Ò #include <iostream>

Ò using namespace std;

Ò int main()

Ò { int n; cout<<"n="; cin>>n;

Ò float a[n];

Ò float s=0;

Ò for (int i=0;i<n; ++i)

Ò {cout<<"a[“<<i<<"]="; cin>>a[i]; //ввод очередного элемента в массив

Ò s+=a[i];} //добавление значения элемента массива к сумме

Ò cout <<"s=“<<s<<endl;

Ò return 0;}

Ò Результат работы программы: n Исходные данные Ответ

Ò 5 23 0 2.5 1.7 -1.5 S = 5

Ò при подсчете суммы используется прием накопления суммы s += a [ i ].

Ò Дан массив из n целых чисел (n<100). Написать программу для подсчета среднего
арифметического четных значений данного массива.

Ò #include <iosfream>

Ò using namespace std;

Ò int main()

Ò { int n; cout<<"n="; cin>>n;

Ò int a[n], k=0;

Ò float s=0;

Ò for (int i=0;i<n; ++i)

Ò { cout<<"a[“<<i<<"]="; cin>>a[i]; //ввод очередного элемента в массив

Ò if (!(a[i]%2)) //если остаток при делении элемента на 2 равен О
{s+=a[i]++k;} //то элемент четный - добавить его к сумме и увеличить
} // количество четных элементов на 1

if (k) // если к не нулевое, то четные числа в последовательности есть

Ò cout <<"sr=“<< s/k<<endl; //и можно вычислить их среднее арифметическое значение else cout<<" четных чисел в последовательности нет “<<endl;

return 0;}

Ò Результат работы n Исходные данные Ответ

Ò программы: 5 1 3 7-41 9 четных чисел в послед-сти нет

Ò 4 2 4 64 sr = 4.00

Выражение a [ i ] %2 будет давать 0, если а [i ] четное число. В C++ 0 трактуется как ложь, поэтому

операторе if ставим операцию логического отрицания (!) перед этим выражением.

Ò Дан массив из n целых чисел (n<100). Написать программу, которая определяет
наименьшее элемент в массиве и его порядковый номер.

Ò #include <iostream>

Ò using namespace std;

Ò int main()

Ò { int n; cout<<"n="; cin>>n;
int a[n];

Ò for (int i=0;i<n; ++i) { cout<<"a[“<<i<<"]="; cin>>a[i];}

Ò int min=a[0]; / / в качестве наименьш.значения полагаем нулевой элемент массива

Ò int nmin=0; //соответственно его порядковый номер равен 0

Ò for (int i=1;i<n; ++i) //перебираем все элементы массива с первого по последний

Ò if (a[i]<min) //если очередной элемент окажется меньше значения min то в качестве

Ò {min=a[i]; //нового наименьш . значения запоминаем значение текущего элемента

Ò nmin=i;} //массива и, соответственно, запоминаем его номер

Ò cout <<"min=“<< min<<"\t nmin=" << nmin<<endl;

return 0;}

Ò Результат работы n Исходные данные Наименьшее значение Его номер

Ò программы: 5 13 7 -41 9 - 41 4

Ò Дан массив из n действительных чисел (n<100). Написать программу, которая меняет местами в этом массиве наибольший и наименьший элемент местами (считается, что в послед-ти только один наибольший и один наименьший элементы).

Ò #include <iostream>

Ò using namespace std;

Ò int main()

Ò { int n; cout<<"n="; cin>>n; ,

Ò float a[n];

Ò for (int i=0;i<n; ++i) {cout<<"a[“<<i<<"]=", cin>>a[i]:}

Ò //первоначально полагаем элемент с номером 0 минимальным и максимальным

Ò float min=a[0], max=a[0];

Ò int nmin=0, nmax=0;

Ò for (int i=1 ;i<n; ++i) // поиск наибольшего и наименьшего значения в массиве и их номеров { if (a[i]<min){min=a[i];nmin=i;}

Ò if(a[i]>max){max=a[i];nmax=i;}}

Ò a[nmax]=min; //в позицию наименьшего элемента записываем значение наибольшего

Ò a[nmin]=max; //в позицию наибольшего элемента записываем значение наименьшего

Ò for (int i=0;i<n; ++i) cout<<a[i]<<"\t"; //выводим измененный массив на экран

Ò return 0;}

Ò Результат работы программы: n Исходные данные Измененные данные

Ò 4 1.1 3.4 -41.2 9.9 1.1 3.4 9.9 -41.2

задание

Ò Дана последовательность целых чисел.

Ò 1. заменить все положительные элементы противоположными числами;

Ò 2. заменить все отрицательные элементы, не кратные 3, противоположными им числами.

Ò 3. подсчитать среднее арифметическое нечётных элементов массива ( для двумерного массива)

Ò 4.подсчитать сумму элементов кратных 9.

Ò 5. заменить все минимальные элементы на противоположные.

Двумерные массивы

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

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

Ò Нумерация строк и столбцов начинается с нулевого номера.

Ò Поэтому если массив содержит три строки и четыре столбца, то строки нумеруются: О, 1, 2; а столбцы: 0, 1, 2, 3.

Ò В C++ двумерный массив реализуется как одномерный, каждый элемент которого также массив.

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

Ò #include <iostream>

Ò using namespace std;

Ò //Функция создает и заполняем двумерный массив

Ò int ** creat(int &n, int &m)

Ò {cout <<"n="; cin >>n; cout <<"m="; cin >>m;

Ò int **mas=new int *[n];

Ò for (int i=0; i<n; ++i) mas[i]=new int [m];

Ò for (int i=0; i<n; ++i)

Ò for (int j=0; j<m; ++j) {cout<<"mas["<<i<<"][“^<< J^<< "]⁼ "; cin.>>mas[i][j];}

Ò return mas;}

Ò P.s

Ò int main()

Ò { int n,m, k=0;

Ò int **a=creat(n,m);

Ò for (int i=0;i<n; ++i) //обработка элементов массива

Ò for (int j=0;j<rn; ++j)

Ò {if (!(a[i][j]%2))//если элемент массива четный, то добавляем его к сумме и

Ò {s+=a[i][fj; к++;}} //увеличиваем количество четных элементов на 1

Ò if (к) cout <<s/k;

Ò else cout«" Четных элементов в массиве нет'";

Ò for (int i=0;i<n; i++) delete [] a[ij; //освобождаем память, выделенную под массив delete [] a;

Ò return 0;}

Ò Результат работы программы: n m Массив Anxm Ответ

Ò 2 3 213 4.00

Ò 136

Ò 3 2 3 чётных элементов

Ò в массиве нет

Ò Дан двумерный массив, элементами которого являются целые числа.

Ò Найти значение максимального элемента массива.

Ò #include <iostream>

Ò using namespace std;

Ò int ** creat(int &n, int &m)

Ò {cout <<"n=";"cin >>n; cout <<"m="; cin >>m;

Ò int **mas=new int *[n];

Ò for (int i=0; i<n; ++i) mas[i]=new int [m];

Ò for (int i=0; i<n; ++i)

Ò for (int j=0; j<m; ++j) {cout<<"mas[“<<i<“][<<“j<<”]=“; cin>>mas[i][j]}

Ò return mas;}

Ò P.s

Ò int main()

Ò {int n,m;

Ò cout <<"n="; cin >>n; cout <<"m="; cin >>m ; //ввели размерность массива

Ò int **a=creat(n,m);

Ò int max=a[0][0]; //первоначально качестве максимального элемента полагаем а[0][0]

Ò for (int i=0;i<n; ++i) // просматриваем все элементы массива

Ò for(intj=0;j<m; +>j)

Ò if (a[i]i[j]>max) // если очередной элемент больше значения максимального,

Ò max=a[i][j]; //то в качестве максимального запоминаем этот элемент

Ò cout<<"max=“<<max;

Ò for (int i=0,i<n; i++) delete [] а[ i] //освобождаем память, выделенную под массив

Ò delete [] а;

Ò return 0;}

Ò Результат работы программы: n m Массив A_n *_m Ответ

Ò 2 3 2 13 6

Ò 1 36

Ò Дана квадратная матрица, элементами которой являются вещественные числа.
Подсчитать сумму элементов главной диагонали.

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

Ò #include <iostream>

Ò using namespace std;

Ò float** creat{irit &n)

Ò {cout <<"n="; cin >>n;

Ò float **mas=new int *[n];

Ò for (int i=0; i<n; ++i) mas{i]=new int [n];

Ò for (int i=0; i<n; ++i)

Ò for (int j=0; j<n; ++j) {cout<<"mas[“<<i<<"][<<“j”<<]; cin>>mas[i][j];}

Ò return mas;}

Ò P.s

Ò int main()

Ò { int n;

Ò float **a=creat(n);

Ò float s=0;

Ò for (int i=0;i<n; i++) //просматриваем все строки массива

Ò s+=a[i][i}; //добавляем к сумме значение элемента стоящего на главной диагонали

Ò cout<<" Сумма элементов главной диагонали =“<<s;

Ò for (int i=0;i<n; i++) delete [] a[i]; //освобождаем память, выделенную под массив

Ò delete [] a;

Ò return 0;}

Ò Результат работы n Массив А_n* n Ответ

Ò программы: 3 2.4 -1.9 3.1 Сумма элементов главной диагонали

Ò 1.1 3.6 -1.2 =4.300

Ò -2.1 4.5 -1.7