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

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

Ò Каждая подпрограмма имеет структуру, подобную функции 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.23 e+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 пропускается; если В ложно, то выполняется оператор S 2, 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;} //полная форма с составными операт

Ò Операторы S 1 и S 2 могут являться операторами 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 ;

case 7: 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 << “ Программа подсчитывает площадь:\ n 1. квадрата;\ n 2. треугольника .\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 *) 0 xB 8000000;

Ò где 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