| Скачать .pptx |
Презентация: Язык программирования С++
С++
// язык программирования
Структура программы С++
Ò Каждая подпрограмма имеет структуру, подобную функции 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.Составить программу, которая для заданного значения х вычисляет значения выражения:
Х2 +sin (x+1)/25, c учётом приоритета операций в с++:
(pow(x,2)+sin(x+1)/25;
2.Написать программу, подсчитывающую площадь квадрата, периметр которого равен p.
Пусть дан квадрат со стороны а , тогда: p = 4a , а = p/4……
s=a2 …………………………… …..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
Ò I1 -множество точек, лежащих внутри области;
Ò I2 - множество точек, лежащих вне области;
Ò I3 - множество точек, образующих границу области. 10 x
-10
Ò Точка с координатами (х, у) может принадлежать только одному из них;
Ò Множества I1 , I2, I3 значительно труднее описать математич-ки, чем интервалы в примере 2,поэтому для проверки выбираются те два множества, которые наиболее просто описать математич-ки.(труднее всего описать точки границы области).
Ò Для рис. 1 множества задаются следующим образом; I 1 :х2 + у2 <102 ; I 2 :х2 + у2 >102 ;
I 3 : х2 +у2 = 102 .
Ò Множества
Ò I 1 :х2 + у2 <102 ; I 2 :х2 + у2 >102 ;
Ò I 3 : х2 +у2 = 102 . рис.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) :
I1 : | х |<10 и |y|<5; I2 : |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 << “Программа подсчитывает площадь:\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 на единицу 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 *) 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 Массив An *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
