// язык программирования
Структура программы С++
Ò Каждая подпрограмма имеет структуру, подобную функции 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 << ‘xt yt &&t||’ endl;
cout << “0t 1t” <<(0 && 1)<< ‘t’ << (0||1) endl;
cout << ‘0t 1t’ <<(0 && 1)<< t’ << (0||1 )endl;
cout << ‘1t 0t’ <<(1 && 0)<< ‘t’ << (1||0) endl;
cout << ‘1t 1t’ <<(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. Составить программу, которая для заданного значения х вычисляет значения выражения:
Х 2
+ 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 1
-множество точек, лежащих внутри области;
Ò I 2
-
множество точек, лежащих вне области;
Ò I 3
- множество точек, образующих границу области. 10 x
-10
Ò Точка с координатами (х, у) может принадлежать только одному из них;
Ò Множества I 1
, I 2,
I 3
значительно труднее описать математич-ки, чем интервалы в примере 2,поэтому для проверки выбираются те два множества, которые наиболее просто описать математич - ки.(труднее всего описать точки границы области).
Ò Для рис. 1 множества задаются следующим образом ; I
1
:х 2
+ у 2
<10 2
;
I
2
:х 2
+ у 2
>10 2
;
I
3
: х 2
+у 2
= 10 2
.
Ò Множества
Ò I
1
:х 2
+ у 2
<10 2
;
I
2
:х 2
+ у 2
>10 2
;
Ò I
3
: х 2
+у 2
= 10 2
.
рис.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 1
: |
х
|<10
и
|y|<5; I 2
: |x| >10
или
|y|>5;
I
3
:(
|х
|
<=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
на единицу
10
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 <<"at bn";
Ò 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