Уроци по С++

[ivakavlad]

Тук ще постна общо 18 глави с уроци по С++ поради това че са много дълги ще ги потвам на части моля потребителите да не пишат докато не свърша със всичките 18 глави ще ви информирам за това като свърша после който иска да добави нещо да заповяда

П.П.Ако модераторите решът, че темата си заслужава може да я направят важна, но това вече те си го преценяват аз почвам с уроците.

[ivakavlad]

Глава 1

Основни елементи
от програмирането на C++


C++ е език за обектно-ориентирано програмиране. Създаден е от Бярн Страуструп от AT&T Bell Laboratories в края на 1985 година. C++ е разширение на езика C в следните три направлнения:
създаване и използване на абстрактни типове данни;
обектно-ориентирано програмиране;
подобрения на конструкции на езика C (производни типове, наследяване, полиморфизъм).
През първите шест месеца след описанието му се появиха над 20 търговски реализации на езика, предназначени за различни компютърни системи. От тогава до сега C++ се разраства чрез добавяне на много нови функции и затова процесът на стандартизацията му продължава и до момента. C++ е пример за език, който с времето расте и се развива. Всеки път, когато потребителите му са забелязвали някакви пропуски или недостатъци, те са го обогатявали със съответните нови възможности.
За разлика от C++, езикът Паскал е създаден планомерно главно за целите на обучението. Проф. Вирт добре е обмислил и доказал езика. Тъй като Паскал е създаден с ясна цел, отделните му компоненти са логически свързани и лесно могат да бъдат комбинирани. Разрастващите се езици, към които принадлежи C++ са доста объркани тъй като хора с различни вкусове правят различни нововъведения. Освен това, заради мобилността на програмите, не е възможно премахването на стари конструкции, даже да съществуват удобни техни подобрения. Така разрастващият се C++ събира в себе си голям брой възможности, които не винаги добре се съвместяват.
Езиците, създадени от компетентни хора, по принцип са лесни за научаване и използване. Разрастващите се езици обаче държат монопола на пазара. Сега C++ е водещия език за програмиране с общо предназначение. Лошото е, че не е много лесен за усвояване, има си своите неудобства и капани. Но той има и огромни приложения – от програми на ниско, почти машинно ниво, до програми от най-висока степен на абстракция.
Целта на настоящия курс по програмиране е не да ви научи на всички възможности на C++, а на изкуството и науката програмиране.
При началното запознаване с езика, възникват два естествени въпроса:
Какво е програма на C++ и как се пише тя?
Как се изпълнява програма на C++?
Ще отговорим на тези въпроси чрез примеp за програма на C++, след което ще дадем някои дефиниции и основни означения.

[ivakavlad]

2.1. Пример за програма на C++

Задача 1. Да се напише програма, която намира периметъра и лицето на правоъгълник със страни 2,3 и 3,7.
Една програма,която решава задачата е следната:
Program Zad1.cpp
#include <iostream.h>
int main()
{double a = 2.3;
double b = 3.7;
double p, s;
/* намиране на периметъра на правоъгълника */
p = 2*(a+b);
/* намиране на лицето на правоъгълника */
s = a*b;
/* извеждане на периметъра */
cout << "p= " << p << "\n";
/* извеждане на лицето */
cout << "s= " << s << "\n";
return 0;
}
Първият ред
#include <iostream.h>
е директива към компилатора на C++. Чрез нея към файла, съдържащ програмата Zad1.cpp, се включва файлът с име iostream.h (При някои реализации на C++ разширението “.h” се пропуска). Този файл съдържа различни дефиниции и декларации, необходими за реализациите на операциите за поточен вход и изход. В програма Zad1.cpp се нуждаем от тази директива заради извеждането върху екрана на периметъра и лицето на правоъгълника.
Конструкцията
int main()
{ …
return 0;
}
дефинира функция, наречена main (главна). Всяка програма на C++ трябва да има функция main. Повечето програми съдържат и други функции освен нея.
Дефиницията на main започва с думата int (съкращение от integer), показваща, че main връща цяло число, а не дроб или низ, например. Между фигурните скобки { и } е записана редица от дефиниции и оператори, която се нарича тяло на функцията. Компонентите на тялото се отделят със знака ; и се изпълняват последователно. С оператора return се означава краят на функцията. Стойността 0 означава, че тя се е изпълнила успешно. Ако програмата завърши изпълнението си и върне стойност различна от 0, това означава, че е възникнала грешка.
Конструкциите
double a = 2.3;
double b = 3.7;
double p, s;
дефинират променливите a, b, p и s от реалния тип double, като в първите два случая се дават начални стойности на a и b (2.3 и 3.7 съответно). Казва се още, че a и b са инициализирани съответно с 2.3 и 3.7.
Променливата е място за съхранение на данни, което може да съдържа различни стойности по време на изпълнение на програмата. Означава се чрез редица от букви, цифри и долна черта, започваща с буква или долна черта. Променливите имат три характеристики: тип, име и стойност. Преди да бъдат използвани, трябва да бъдат дефинирани.
C++ е строго типизиран език за програмиране. Всяка променлива има тип, който явно се указва при дефинирането й. Пропускането на типа на променливата води до сериозни грешки. Фиг. 1. илюстрира непълно дефинирането на променливи.


Дефиниране на променливи
Синтаксис
<име_на_тип> <променлива> [ = <израз> ]
{, <променлива> [ = <израз> ] };
където
<име_на_тип> е дума, означаваща име на тип като int, double и др.;
<израз> е правило за получаване на стойност – цяла, реална, знакова и др. тип, съвместим с <име_на_тип>.
Семантика
Дефиницията свързва променливата с множеството от допустимите стойности на типа, от който е променливата или с конкретна стойност от това множество. За целта се отделя определено количество оперативна памет (толкова, колкото да се запише най-голямата константа от множеството от допустимите стойности на съответния тип) и се именува с името на променливата. Тази памет е с неопределено съдържание или съдържа стойността на указания израз, ако е направена инициализация.
Не се допуска една и съща променлива да има няколко дефиниции в рамките на една и съща функция.



Фиг. 1.

В случая на програмата Zad1.cpp за a, b, p и s се отделят по 8 байта оперативна памет и
ОП
a b p s
2.3 3.7 - -
8 байта 8 байта 8 байта 8 байта
Неопределеността на p и s ще означаваме с -.
След дефинициите на променливите a, b, p и s е разположен коментарът
/* намиране на периметъра на правоъгълника */
Той е предназначен за програмиста и подсеща за смисъла на следващото действие.
Коментарът (Фиг. 2) е произволен текст, ограден със знаците /* и */. Игнорира се напълно от компилатора.


Коментар
Синтаксис
<коментар> ::= /* <редица_от_знаци> */
Семантика
Пояснява програмен фрагмент. Предназначен е за програмиста. Игнорира се от компилатора на езика.


Фиг. 2.

Конструкциите
p = 2*(a+b);
s = a*b;
са оператори за присвояване на стойност (Фиг. 3). Чрез тях променливите p и s получават текущи стойности. Операторът
p = 2*(a+b);
пресмята стойността на аритметичния израз 2*(a+b) и записва полученото реално число (в случая 12.0) в паметта, именувана с p. Аналогично, операторът
s = a*b;
пресмята стойността на аритметичния израз a*b и записва полученото реално число (в случая 8.51) в паметта, именувана със s.
По-подробно ще разгледаме този оператор в следващата глава. На този етап оставяме с интуитивната представа за <израз>. Ще се ограничим с лява страна от вида променлива. Ще отбележим само, че езикът C++ поддържа псевдоними, което дава възможност лявата страна на оператора за присвояване да бъде израз, чиято стойност е псевдоним на модифицируем обект.

[ivakavlad]

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

Синтаксис
<променлива> = <израз>;
като <променлива> и <израз> са от един и същ тип.
Семантика
Пресмята стойността на <израз> и я записва в паметта, именувана с променливата от лявата страна на знака за присвояване =.

Фиг. 3.

Да се върнем към дефинициите на променливите a и b и операторите за присвояване и return на Zad1.cpp. Забелязваме, че в тях са използвани два вида числа: цели (2 и 0) и реални (2.3 и 3.7). Целите числа се записват като в математиката, а при реалните, знакът запетая се заменя с точка. Умножението е отбелязано със *, а събирането – с +. Забелязваме също, че изразите 2*(a+b) и a*b са реални, каквито са и променливите p и s от левите страни на знака = в операторите за присвояване.
Конструкциите
cout << "p= " << p << "\n";
cout << "s= " << s << "\n";
са оператори за извеждане. Наричат се още оператори за поточен изход. Еквивалентни са на редицата от оператори
cout << "p= ";
cout << p;
cout << "\n";
cout << "s= ";
cout << s;
cout << "\n";
Операторът << означава “изпрати към”. Обектът (променливата) cout (произнася се “си-аут”) е името на стандартния изходен поток, който обикновено е екрана или прозорез на екрана.
Редица от знаци, оградена в кавички, се нарича знаков низ, или символен низ, или само низ. В програмата Zad1.cpp “p= “ и “s= “ са низове. Низът “\n“ съдържа двойката знаци \ (backslash) и n, но те представляват един-единствен знак, който се нарича знак за нов ред. Операторът
cout << "p= ";
извежда върху екрана низа
p=
Операторът
cout << p;
извежда върху екрана стойността на p, а
cout << "\n";
премества курсора на следващия ред на екрана, т.е. указва следващото извеждане да бъде на нов ред.
Фиг. 7. показва по-детайлно синтаксиса и семантиката на оператора за извеждане.

Изпълнение на Zad1.cpp
След обработката на директивата
#include <iostream.h>
файлът iostream.h е включен във файла, съдържащ функцията main на Zad1.cpp. Изпълнението на тялото на main започва с изпълнение на дефинициите
double a = 2.3;
double b = 3.7;
double p, s;
в резултат, на което в ОП се отделят по 8 байта за променливите a, b, p и s, т.е.
ОП
a b p s
2.3 3.7 - -
Коментарите се пропускат. След изпълнението на операторите за присвояване:
p = 2*(a+b);
s = a*b;
променливите p и s се свързват с 12.0 и 8.51 съответно, т.е.
ОП
a b p s
2.3 3.7 12.0 8.51
Операторите
cout << "p= " << p << "\n";
cout << "s= " << s << "\n";
извеждат върху екрана на монитора
p= 12
s= 8.51
Изпълнението на оператора
return 0;
преустановява работата на програмата сигнализирайки, че тя е завършила успешно.
Забележка: Реалните числа се извеждат с възможно минималния брой знаци. Така реалното число 12.0 се извежда като 12.
В същност, описаните действия се извършват над машинния еквивалент на програмата Zad1.cpp. А как се достига до него?

[ivakavlad]

Изпълнение на програма на езика C++

За целта се използва някаква среда за програмиране на C++. Ние ще изплзваме Visual C++ версия 6.0.
Изпълнението се осъществява чрез преминаване през следните стъпки:
Създаване на изходен код
Чрез текстовия редактор на средата, текстът на програмата се записва във файл. Неговото име се състои от две части – име и разширение. Разширението подсказва предназначението на файла. Различно е за отделните реализации на езика. Често срещано разширение за изходни файлове е “.cpp” или “.c”.
Примерната програма е записана във файла Zad1.cpp.
Компилиране
Тази стъпка се изпълнява от компилатора на езика. Първата част от работата на компилатора на C++ е откриването на грешки – синтактични и грешки, свързани с типа на данните. Съобщението за грешка съдържа номера на реда, където е открита грешка и кратко описание на предполагаемата причина за нея. Добре е грешките да се корегират в последователността, в която са обявени, защото една грешка може да доведе до т. нар. “каскаден ефект”, при който компилаторът открива повече грешки, отколкото реално съществуват. Коригираният текст на програмата трябва да се компилира отново. Втората част от работата на компилатора е превеждане (транслиране) на изходния (sourse) код на програмата в т. нар. обектен код. Обектният код се състои от машинни инструкции и информация за това, как да се зареди програмата в ОП, преди да започне изпълнението й. Обектният код се записва в отделен файл, обикновено със старото име, но с разширение “.obj” или “.o”.
Обектният файл съдържа само “превода” на програмата, а не и на библиотеките, които са декларирани в нея (в случая на програмата Zad1.cpp файлът Zad1.obj не съдържа обектния код на iostream.h). Авторите на пакета iostream.h са описали всички необходими действия и са записали нужния машинен код в библиотеката iostream.h.
Свързване
Обектният файл и необходимите части от библиотеки се свързват в т. нар. изпълним файл. Това се извършва от специална програма, наречена свързваща програма или свързващ редактор (linker). Изпълнимият файл има името на изходния файл, но разширението му обикновено е “.exe”. Той съдържа целия машинен код, необходим за изпълнението на програмата. Този файл може да се изпълни и извън средата за програмиране на езика C++.
Фиг. 4 илюстрира стъпките на изпълнение на програма на C++.

[ivakavlad]

Фиг. 4

Програмистката дейност, свързана с изпълнението на програма на C++, преминава през три стъпки като реализира цикъла “редактиране-компилиране-настройка”. Започва се с редактора като се пише изходният файл. Компилира се програмата и ако има синтактични грешки, чрез редактора се поправят грешките. Когато програмата е “изчистена” от синтактичните грешки, започва изпълнението й. Ако възникнат грешки по време на изпълнението, се осъществява връщане отново в редактора и се поправят предполагаемите грешки. После пак се компилира и стартира програмата. Цикълът “редактиране-компилиране-настройка” е илюстриран на фиг.5

[ivakavlad]

2.2. Основни означения

Всяка програма на C++ е записана като редица от знаци, които принадлежат на азбуката на езика.

Азбука на C++

Азбуката на езика включва:
главните и малки букви на латинската азбука;
цифрите;
специалните символи
+ - * / = ( ) [ ] { } | : ; “ ‘ < > , . _ ! @ # $ % ^ ~
Някой от тези знаци, по определени правила, са групирани в думи (лексеми) на езика.

Думи на езика

Думите на езика са идентификатори, запазени и стандартни думи, константи, оператори и препинателни знаци.

Идентификатори

Редица от букви, цифри и знака за подчертаване (долна черта), започваща с буква или знака за подчертаване, се нарича идентификатор.
Примери:
Редиците от знаци
A12 help Help double int15_12 rat_number INT1213 Int15_12
са идентификатори, а редиците
1ba ab+1 a(1) a’b
не са идентификатори. В първия случай редицата започва със цифра, а в останалите – редиците съдържат недопустими за идентификатор знаци.
Идентификаторите могат да са с произволна дължина. В съвременните компилатори максималният брой знаци на идентификаторите може да се задава, като подразбиращата се стойност е 32.
Забележка: При идентификаторите се прави разлика между малки и главни букви, така help, Help, HELP, HeLp и HElp са различни идентификатори.
Идентификаторите се използват за означаване на имена на променливи, константи, типове, функции, класове, обекти и други компоненти на програмите.
Препоръка: Не започвайте вашите идентификатори със знака за подчертаване. Такива идентификатори се използват от компилатора на C++ за вътрешно предназначение.
Допълнение: Чрез метаезика на Бекус-Наур, синтаксисът на променливите се определя по следния начин:
<променлива> ::= <идентификатор>

Някои идентификатори са резервирани в езика.

Запазени думи

Това са такива идентификатори, които се използват в програмите по стандартен, по предварително определен начин и които не могат да бъдат използвани по друг начин. Чрез тях се означават декларации, дефиниции, оператори, модификатори и други конструкции. Реализацията Visual C++ 6.0 съдържа около 70 такива думи.
В програмата Zad1.cpp са използвани запазените думи int, double, return.

Стандартни думи

Това са такива идентификатори, които се използват в програмите по стандартен, по предварително определен начин. Тези идентификатори могат да се използват и по други начини, например като обикновени идентификатори.
В програмата Zad1.cpp е използвана стандартната дума cout.
Например,
#include <iostream.h>
int main()
{int cout = 21;
return 0;
}
е допустима програма на C++. В нея идентификаторът cout е използван като име на променлива. Правенето на опит за използване на cout по стандартния начин води до грешка. Така фрагментът
#include <iostream.h>
int main()
{int cout = 21;
cout << cout << “\n”;
return 0;
}
е недопустим.
Препоръка: Стандартните думи да се използват само по стандартния начин.

Константи

Данна, която не може да бъде променяна, се нарича константа. Има числови, знакови, низови и др. видове константи.
Целите и реалните числа са числови константи. Целите числа се записват както в математиката и могат да бъдат задавани в десетична, шестнадесетична или осмична бройна система. Реалните числа се записват по два начина: във формат с фиксирана точка (например, 2.34 -12345.09 и в експоненциален формат (например, 5.23е-3 и 5.23Е-3 означават 5.23 умножено с 10-3).
Низ, знаков низ или символен низ е крайна редица от знаци, оградени в кавички. Например, редиците: “Това е низ.”, “1+23-34”, “Hellow\n” са низове.
Забележка: Операторът
cout << “Hellow\n”;
извежда върху екрана поздрава Hellow и премества курсора на нов ред.

Оператори

В C++ има три групи оператори: аритметично - логически, управляващи и оператори за управление на динамичната памет.

аритметично-логически оператори
Наричат се още аритметично-логически операции. Те реализират основните аритметични и логически операции като: събиране (+), изваждане (-), умножение (*), деление (/), логическо И (&&, and), логическо ИЛИ (||, or) и др. В програмата Zad1.cpp бяха използвани * и +.

управляващи оператори
Това са конструкции, които управляват изчислителния процес. Такива са условния оператор, оператора за цикъл, за безусловен преход и др.

операторите за управление на динамичната памет
Те позволяват по време на изпълнение на програмата да бъде заделяна и съответно освобождавана динамична памет.

Препинателни знаци

Използват се ; < > { } ( ) и др. знаци.

Разделяне на думите

В C++ разделителите на думите са интервалът, вертикалната и хоризонталната табулации и знакът за нов ред.

Коментари

Коментарите са текстове, които не се обработват от компилатора, а служат само като пояснения за програмистите. В C++ има два начина за означаване на коментари. Единият начин е, текстът да се огради с /* и */. Използвахме го вече в Zad1.cpp. Тези коментари не могат да бъдат влагани. Другият начин са коментарите, които започват с // и завършват с края на текущия ред.
Коментарите са допустими навсякъде, където е допустим разделител.
Забележка: Не се препоръчва използването на коментари от вида // в редовете на директивите на компилатора.

[ivakavlad]

2.3. Вход и изход

Програма Zad1.cpp намира периметъра и лицето само на правоъгълник със страни 2.3 и 3.7. Нека решим тази задача в общия случай.
Задача 2. Да се напише програма, която въвежда размерите на правоъгълник и намира периметъра и лицето му.

Програмата Zad2.cpp решава тази задача.
Program Zad2.cpp
#include <iostream.h>
int main()
{// въвеждане на едната страна
cout << "a= ";
double a;
cin >> a;
// въвеждане на другата страна
cout << "b= ";
double b;
cin >> b;
// намиране на периметъра
double p;
p = 2*(a+b);
// намиране на лицето
double s;
s = a*b;
// извеждане на периметъра
cout << "p= " << p << "\n";
// извеждане на лицето
cout << "s= " << s << "\n";
return 0;
}
Когато програмата бъде стартирана, върху екрана ще се появи подсещането
a=
което е покана за въвеждане размерите на едната страна на правоъгълника. Курсорът стои след знака =. Очаква се да бъде въведено число (цяло или реално), след което да бъде натиснат клавишът ENTER.
Следва покана за въвеждане на стойност за другата страна на правоъгълника, след което програмата ще изведе резултата и ще завърши изпълнението си.
Въвеждането на стойността на променливата a се осъществява с оператора за вход
cin >> a;
Обектът cin е името на стандартния входен поток, обикновено клавиатурата на компютъра. Изпълнението му води до пауза до въвеждане на число и натискане на клавиша ENTER. Нека за стойност на a е въведено 5.65, следвано от ENTER. В буфера на клавиатурата се записва
cin




След изпълнението на
cin >> a;
променливата a се свързва с 5.65, а в буфера на клавиатурата остава знакът \n, т.е.
cin



ОП
a
5.65
Въвеждането на стойността на променливата b се осъществява с оператора за вход
cin >> b;
Изпълнението му води до пауза до въвеждане на число и натискане на клавиша ENTER. Нека е въведено 8.3, следвано от ENTER. В буфера на клавиатурата имаме:
cin



Изпълнението на оператора
cin >> b;
прескача знака \n, свързва 8.3 с променливата b, а в буфера на клавиатурата отново остава знакът \n, т.е.
cin



ОП
a b
5.65 8.3
Чрез оператора за вход могат да се въвеждат стойности на повече от една променлива. Фиг. 6 съдържа по-пълно негово описание.
Входът от клавиатурата е буфериран. Това означава, че всяка редица от натиснати клавиши се разглежда като пакет, който се обработва чак след като се натисне клавишът ENTER.


Оператор за вход >>
Синтаксис
cin >> <променлива>;
където
- cin е обект (променлива) от клас (тип) istream, свързан с клавиатурата,
- <променлива> е идентификатор, дефиниран, като променлива от “допустим тип”, преди оператора за въвеждане. (Типовете int, long, double са допустими).
Семантика
Извлича (въвежда) от cin (клавиатурата) поредната дума и я прехвърля в аргумента-приемник <променлива>. Конструкцията
cin >> <променлива>
е израз от тип istream със стойност левия му аргумент, т.е. резултатът от изпълнението на оператора >> е cin. Това позволява няколко думи да бъдат извличани чрез верига от оператори >>.
Следователно, допустим е следният по-общ синтаксис на >>:
cin >> <променлива> { >> <променлива>};
Операторът >> се изпълнява отляво надясно. Такива оператори се наричат ляво асоциативни. Така операторът
cin >> променлива1 >> променлива2 >> … >> променливаn;
е еквивалентен на редицата от оператори:
cin >> променлива1;
cin >> променлива2;
…
cin >> променливаn;
Освен това, ако операцията въвеждане е завършила успешно, състоянието на cin е true, в противен случай състоянието на cin е false.


Фиг. 6.

В случая от Фиг. 6, настъпва пауза. Компилаторът очаква да бъдат въведени n стойности - за променлива1, променлива2,, …, променливаn, съответно и бъде натиснат клавишът ENTER. Тези стойности трябва да бъдат въведени по подходящ начин (на един ред, на отделни редове или по няколко данни на последователни редове, слепени или разделени с интервали, табулации или знака за нов ред), като стойностi трябва да бъде от тип, съвместим с типа на променливаi (i = 1, 2, …, n).
Пример: Да разгледаме програмния фрагмент:
double a, b, c;
cin >> a >> b >> c;
Операторът за вход изисква да бъдат въведени три реални числа за a, b и c съответно. Ако се въведат
1.1 2.2 3.3 ENTER
променливата a ще се свърже с 1.1, b – с 2.2 и c – със 3.3. Същият резултат ще се получи, ако се въведе
1.1 2.2 ENTER
3.3 ENTER
или
1.1 ENTER
2.2 3.3 ENTER
или
1.1 ENTER
2.2 ENTER
3.7 ENTER
или даже ако се въведе
1.1 2.2 3.3 4.4 ENTER
В последния случай, стойността 4.4 ще остане необработена в буфера на клавиатурата и ще обслужи следващо четене, ако има. Този начин на действие съвсем не е приемлив. Още по-лошо ще стане когато се въведат данни от неподходящ тип.
Пример: Да разгледаме фрагмента:
int a;
cin >> a;
Той дефинира целочислена променлива a (a е променлива от тип int), след което настъпва пауза в очакване да бъде въведено цяло число. Нека сме въвели 1.25, следвано от ENTER. Състоянието на буфера на клавиатурата е:
cin




Операторът
cin >> a;
свързва a с 1, но не прескача останалата информация от буфера и тя ще обслужи следващо четене, което води до непредсказуем резултат. Още по-неприятна е ситуацията, когато вместо цяло число за стойност на a се въведе някакъв низ, например one, следван от ENTER. В този случай, изпълнението на
cin >> a;
ще доведе до
cin




и
ОП
a
-
т.е. стойността на променливата a не се променя (остава неопределена), а буферът на клавиатурата изпада в състояние fail. За съжаление системата не извежда съобщение за грешка, което да уведоми за възникналия проблем.
Засега препоръчваме въвеждането на коректни входни данни. Преудоляването на недостатъците, илюстрирани по-горе, ще разгледаме в следващите части на книгата.

Вече използвахме оператора за изход. Фиг. 7 описва неговите синтаксис и семантика.

[ivakavlad]

2.4. Структура на програмата на C++

Когато програмата е малка, естествено е целият й код да бъде записан в един файл. Когато програмите са по-големи или когато се работи в колектив, ситуацията е по-различна. Налага се да се раздели кодът в отделни изходни (source) файлове. Причините, поради които се налага разделянето, са следните. Компилирането на файл отнема време и е глупаво да се чака компилаторът да транслира отново и отново код, който не е бил променян. Трябва да се компилират само файловете, които са били променяни.

Оператор за изход <<
Синтаксис
cout << <израз>;
където
- cout е обект (променлива) от клас (тип) ostream и предварително свързан с екрана на компютъра;
- <израз> е израз от допустим тип. Представата за израз продължава да бъде тази от математиката. Допустими типове са bool, int, short, long, double, float и др.
Семантика
Операторът << изпраща (извежда) към (върху) cout (екрана на компютъра) стойността на <израз>. Конструкцията
cout << <израз>
е израз от тип ostream и има стойност първия му аргумент, т.е. резултатът от изпълнението на оператора << в горния случай е cout. Това позвалява чрез верига от оператори << да бъдат изведени стойностите на повече от един <израз>, т.е. допустим е следният по-общ синтаксис:
cout << <израз> { << <израз>};
Операторът << се изпълнява отляво надясно (ляво асоциативен е). Така операторът
cout << израз1 << израз2 << … << изразn
е еквивалентен на редицата от оператори:
cout << израз1;
cout << израз2;
…
cout << изразn;


Фиг. 7.

Друга причина е работата в колектив. Би било трудно много програмисти да редактират едновременно един файл. Затова кодът на програмата се разделя така, че всеки програмист да отговаря за един или няколко файлове.
Ако програмата се състои от няколко файла, трябва да се каже на компилатора как да компилира и изгради цялата програма. Това ще направим в следващите раздели. Сега ще дадем най-обща представа за структурата на изходните файлове. Ще ги наричаме още модули.
Изходните файлове се организират по следния начин:

<изходен_файл> ::= <заглавен_блок_с_коментари >
<заглавни_файлове>
<константи>
<класове>
<глобални_променливи>
<функции>

Заглавен блок с коментари

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

Заглавни файлове

В тази част на модула са изброени всички необходими заглавни файлове. Например
#include <iostream.h>
#include <cmath.h>
Забелязваме, че за разделител е използван знакът за нов ред, а не ;.

Константи

В тази част се описват константите, необходими за модула. Вече имаме някаква минимална представа за тях. По-подробно описание на синтаксиса и семантиката им е дадена на Фиг. 8. За да бъде програмата по-лесна за четене и модифициране, е полезно да се дават символични имена не само на променливите, а и на константите. Това става чрез дефинирането на константи.

Задача 3. Да се напише програма, която въвежда радиуса на окръжност и намира и извежда дължината на окръжността и лицето на кръга с дадения радиус.
Една програма, която решава задачата е следната:

Program Zad3.cpp
#include <iostream.h>
const double PI = 3.1415926535898;
int main()
{ double r;
cout << “r= “;
cin >> r;
double p = 2 * PI * r;
double s = PI * r * r;
cout << “p=” << p << “\n”;
cout << “s=” << s << “\n;
return 0;
}
В тази програма е дефинирана реална константа с име PI и стойност 3.1415926535898, след което е използвано името PI.

Дефиниране на константи
Синтаксис
const <име_на_тип> <име_на_константа> = <израз>;
където
const е запазена дума (съкращение от constant);
<име_на_тип> е идентификатор, означаващ име на тип;
<име_на_константа> е идентификатор, обикновено състоящ се от главни букви, за да се различава визуално от променливите.
<израз> е израз от тип, съвместим с <име_на_тип>.
Семантика
Свързва <име_на_константа> със стойността на <израз>. Правенето на опит да бъде променяна стойността на константата предизвиква грешка.

Фиг. 8.

Примери:
const int MAXINT = 32767;
const double RI = 2.5 * MAXINT;

Предимства на декларирането на константите:
- Програмите стават по-ясни и четливи.
- Лесно (само на едно място) се променят.
- Вероятността за грешки, възможни при многократното изписване на стойността на константата, намалява.
Забележка: Тъй като в програмата Zad3.cpp е използвана само една
функция (main), декларацията на константата PI може да се постави във функцията main, преди първото нейно използване.

Класове

Тази част съдържа дефинициите на класовете, използвани в модула.
В езика C++ има стандартен набор от типове данни като int, double, float, char, string и др. Този набор може да бъде разширен чрез дефинирането на класове.
Дефинирането на клас въвежда нов тип, който може да бъде интегриран в езика. Класовете са в основата на обектно-ориетираното програмиране, за което е предназначен езика C++.
Дефинирането и използването на класове ще бъде разгледано по-късно.

Глобални променливи

Езикът поддържа глобални променливи. Те са променливи, които се дефинират извън функциите и които са “видими” за всички функции, дефинирани след тях. Декларират се както се дефинират другите (локалните) променливи. Използването на много глобални променливи е лош стил за програмиране и не се препоръчва. Всяка глобална променлива трябва да е съпроводена с коментар, обясняващ предназначението й.

Функции
Всеки модул задължително съдържа функция main. Възможно е да съдържа и други функции. Тогава те се изброяват в тази част на модула. Ако функциите са подредени така, че всяка от тях е дефинирана преди да бъде извикана, тогава main трябва да бъде последна. В противен случай, в началото на тази част на модула, трябва да се декларират всички функции.



Задачи

Задача 1. Кои от следните редици от знаци са идентификатори, кои не и защо?
а) a б) x1 в) x1 г) x’ д) x1x2
е) sin ж) sin x з) cos(x) и) x-1 к) 2a
л) min 1 м) Beta н) a1+a2 о) k”m п) sin’x
Задача 2. Намерете синтактичните грешки в следващата програма:
include <iostream>
int Main()
{ cout >> “a, b = “;
cin << a, b;
cout << “The product of “ << a << “and” << b << “is: “
<< a*b < “\n”
return 0;
}
Задача 3. Напишете програма, която разменя стойностите на две числови променливи.
Задача 4. Напишете програма, която намира минималното (максималното) от две цели числа.
Задача 5. Напишете програма, която изписва с главни букви текста Hellow World.
Упътване: Голямата буква H може да се представи така:
о о
о о
о о
ооооо
о о
о о
о о
и да се реализира по следния начин:
char* let_H = “o o\no o\no o\nooooo\no o\no o\no o\n”;
където char* означава тип низ.



Допълнителна литература

Г. Симов, Програмиране на C++, С., СИМ, 1993.
К. Хорстман, Принципи на програмирането със C++, С., СОФТЕХ, 2000.
П. Лукас, Наръчник на програмиста, С., Техника, 1994.

[ivakavlad]

Глава2

Скаларни типове данни


Езикът C++ е изключително мощен по отношение на типовете данни, които притежава. Най-общо, типовете му могат да бъдат разделени на: вградени и абстрактни.
Вградените типове са предварително дефинирани и се поддържат от неговото ядро.
Абстрактните типове се дефинират от програмиста. За целта се определят съответни класове.
Една непълна класификация на вградените типове данни е дадена на Фиг. 1.

Вградени типове данни


Скаларни типове Съставни типове


Булев масив
Числови типове вектор
Изброен
Указател
Псевдоним

Фиг. 1.

Скаларни са типовете данни, които се състоят от една компонента (число, знак и др.).
Съставни типове са онези типове данни, компонентите на които са редици от елементи.
Типът указател дава средства за динамично разпределение на паметта.
В тази глава ще разгледаме само някои скаларни типове данни.
Всеки тип се определя с множество от допустими стойности (множество от стойности) и операции и вградени функции, които могат да се прилагат над елементите от множеството от стойностите му.

[ivakavlad]

3.1. Логически тип

Нарича се още булев тип в чест на Дж. Бул, английски логик, поставил основите на математическата логика.
Типът е стандартен, вграден в реализацията. За означаването му се използва запазената дума bool (съкращение от boolean).

Множество от стойности

Състои се от два елемента – стойностите true (истина) и false (лъжа). Тези стойности се наричат още булеви константи.

<булева_константа> ::= true | false.

Променлива величина, множеството от допустимите стойности, на която съвпада с множеството от стойности на типа булев, се нарича булева или логическа променлива или променлива от тип булев. Дефинира се по обичайния начин.
Примери:
bool b1, b2;
bool b3 = false;
Дефиницията свързва булевите променливи с множеството от стойности на типа булев или с конкретна стойност от това множество като отделя по 1 байт оперативна памет за всяка от тях. Съдържанието на тази памет е неопределено или е булевата константа, свързана с дефинираната прменлива, в случай, че тя е инициализирана.
След дефиницията от примера по-горе, имаме:
ОП
b1 b2 b3
- - false
1 байт 1 байт 1 байт
Съдържанието на паметта, именувана с b1 и b2 е неопределено, а това на именуваната с b3 е false. В същност, вместо false в паметта е записан кодът (вътрешното представяне) на false - 0.
Вътрешните представяния на булевите константи са:
false 0
true 1

Операции и вградени функции

Логически операции

Конюнкция (логическо умножение)

Тя е двуаргументна (бинарна) операция. Означава се с and или && (за Visual C++, 6.0) и се дефинира по следния начин:


А B A and B
false false false
false rue false
true false false
true true true


Операцията се поставя между двата си аргумента. Такива операции се наричат инфиксни.

Дизюнкция (логическо събиране)
Тя е бинарна, инфиксна операция. Означава се с or или || (за Visual C++, 6.0) и се дефинира по следния начин:


А B A or B
false false false
false true true
true false true
true true true


Логическо отрицание

Тя е едноаргументна (унарна) операция. Означава се с not или ! (за Visual C++, 6.0) и се дефинира по следния начин:


А not A
false true
true false


Поставя се пред единствения си аргумент. Такива оператори се наричат префиксни.
Забележка: Може да няма разделител между оператора ! и константите true и false, т.е. записите !true и !false са допустими.
Допълнение: Смисълът на операторите and, or и not е разширен чрез разширяване смисъла на булевите константи. Прието е, че true е всяка стойност, различна от 0 и че false е стойността 0.

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

Над булевите данни могат да се извършват следните инфиксни операции за сравнение:
== - за равно
!= - за различно
> - за по-голямо
>= - за по-голямо или равно
< - за по-малко
<= - за по-малко или равно
Сравняват се кодовете.
Примери:
false < true е true
false > false е false
true >= false е true

Въвеждане

Не е възможно въвеждане на стойност на булева променлива чрез оператора >>, т.е. операторът
cin >> b1;
е недопустим, където b1 е булевата променлива, дефинирана по-горе.

Извеждане

Осъществява се чрез оператора
cout << <булева_константа>;
или по-общо
cout << <булев_израз>;
където синтактичната категория <булев_израз> е определена по-долу.
Извежда се кодът на булевата константа или кодът на булевата константа, която е стойност на <булев_израз>.

Булеви изрази

Булевите изрази са правила за получаване на булева стойност. Дефинират се рекурсивно по следния начин:
Булевите константи са булеви изрази.
Булевите променливи са булеви изрази.
Прилагането на булевите оператори not (!), and (&&), or (||) над булеви изрази е булев израз.
Прилагането на операциите за сравнение ==, !=, >, >=, <, <= към булеви изрази е булев израз.

Примери: Нека имаме дефиницията
bool b, b1, b2;
Следните изрази са булеви:

true b b1 b2 !false !!b !b1 || b2
!!!b && !!!!!b2 b < !b2 false >= b b1 == b2 > b b != b1

Тази дефиниция е непълна. Ще отбележим само, че сравнението на аритметични изрази чрез изброените по-горе операции за сравнение, е булев израз. Освен това, аритметичен израз, поставен на място, където синтаксисът изисква булев израз, изпълнява ролята на булев израз. Това е резултат от разширяването смисъла на булевите константи true и false, чрез приемането всяка стойност, различна от 0 да се интерпретира като true и 0 да се интерпретира като false.
Засега отлагаме разглеждането на семантиката на булевите изрази. Това ще направим след разглеждане на аритметичните изрази

[ivakavlad]

3.2. Числени типове

3.2.1. Целочислени типове

Ще разгледаме целочисления тип int.
Типът е стандартен, вграден в реализацията на езика. За означаването му се използва запазената дума int.

Множество от стойности

Множеството от стойности на типа int зависи от хардуера и реализацията и не се дефинира от ANSI (American National Standarts Institute). Състои се от целите числа от някакъв интервал. За реализацията Visual C++ 6.0, това е интервалът [-2147483648, 2147483647].
Целите числа се записват като в математиката, т.е.
<цяло_число> ::= [+|-]<цяло_без_знак>
<цяло_без_знак> ::= <цифра>|
<цифра><цяло_без_знак>
<цифра> ::= 0| 1| … |9.
Обикновено знакът + се пропуска.
Допълнение: Целите числа могат да са в десетична, осмична и шестнадесетична позиционна система. Осмичните числа започват с 0 (нула), а шестнадесетичните - с 0x (нула, x).

Елементите от множеството от стойности на типа int се наричат константи от тип int.

Променлива величина, множеството от допустимите стойности, на която съвпада с множеството от стойности на типа int, се нарича цяла променлива или променлива от тип int.
Дефинира се по обичайния начин. Дефиницията свързва променливите от тип int с множеството от стойности на типа int или с конкретна стойност от това множество като отделя по 4 байта (1 дума) оперативна памет за всяка от тях. Ако променливата не е била инициализирана, съдържанието на свързната с нея памет е неопределено, а в противен случай – съдържа указаната при инициализацията стойност.
Примери:
int i;
int j = 56;
След тези дефиниции, имаме:
ОП
i j
- 56
4 байта 4 байта

Операции и вградени фунции

Аритметични операции

Унарни операции
Записват се пред или след единствения си аргумент.

+, - са префиксни операции. Потвърждават или променят
знака на аргумента си.
Примери: Нека
int i = 12, j = -7;
Следните означения съдържат унарна операция + или -:
-i +j -j +i -567

Бинарни операции
Имат два аргумента. Следните аритметични операции са инфиксни:

+ - събиране
- - изваждане
* - умножение
/ - целочислено деление
% - остатък от целочислено деление.

Примери:
15 – 1235 = -1220 13 / 5 = 2
15 + 1235 = 1250 13 % 5 = 3
-15 * 123 = -1845 23 % 3 = 2
Забележка: Допустимо е използването на два знака за аритметични операции, но единият трябва да е унарен. Например, допустими са 5-+4, 5+-4, имащи стойност 1, а също 5*-4, равно на –20.

Логически операции

Логическите операции конюнкция, дизюнкция и отрицание могат да се прилагат над целочислени константи. Дефинират се по същия начин, като целите числа, които са различни от 0 се интерпретират true, а 0 – като false.
Примери:
123 and 0 е false
0 or 15 е true
not 67 е false

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

Над целочислени константи могат да се извършват следните инфиксни операции за сравнение:
== - за равно != - за различно
> - за по-голямо >= - за по-голямо или равно
< - за по-малко <= - за по-малко или равно.
Наредбата на целите числа е като в математиката.
Примери:
123 < 234 е true
-123456 > 324 е false
23451 >= 0 е true

Вградени функции

В езика C++ има набор от вградени функции. Обръщението към такива функции има следния синтаксис:
<име_на_функция>(<израз>, <израз>, …, <израз>)
и връща стойност от типа на функцията.

Тук ще разгледаме само едноаргументната целочислена функция abs.

аbs(x) – намира |x|, където x е цял израз
(в частност цяла константа).

Примери:
abs(-1587) = 1587 abs(0) = 0 abs(23) = 23

За използването на тази функция е необходимо в частта на заглавните файлове да се включи директивата:
#include <math.h>
Библиотеката math.h съдържа богат набор от функции. В някой реализации тя има име math или cmath.

Въвеждане

Реализира се по стандартния и разгледан вече начин.
Пример: Ако
int i, j;
операторът
cin >> i >> j;
въвежда стойности на целите променливи i и j. Очаква се въвеждане от стандартния входен поток на две цели константи от тип int, разделени с интервал, знаците за хоризонтална или вертикална табулация или знака за преминаване на нов ред.

Извеждане

Реализира се чрез оператора
cout << <цяла_константа>;
или по-общо
cout << <цял_израз>;
В текущата позиция на курсора се извежда константата или стойността на целия израз. Използва се минималното количество позиции, необходими за записване на цялото число.
Пример: Нека имаме дефиницията
int i = 1234, j = 9876;
Операторът
cout << i << j << “\n”;
извежда върху екрана стойностите на i и j, но слепени
12349876
Този изход не е ясен. Налага се да се извърши форматиране на изхода. То се осъществява чрез подходящи манипулатори.

Манипулатор setw
Setw е вградена функция.
Синтаксис
setw(<цял_израз>)
Семантика
Стойността на <цял_израз> задава широчината на полето на следващия изход.
Пример: Операторът
cout << setw(10);
не извежда нищо. Той “манипулира” следващото извеждане като указва, че в поле с широчина 10 отдясно приравнена, ще бъде записана следващата извеждана цяла константа.
Забележка: Този манипулатор важи само за първото след него извеждане.
Пример: Нека
ОП
i j
1234 9876
Операторът
cout << setw(10) << i << j << “\n”;
извежда отново стойностите на i и j слепени, като 1234 се предшества от 6 интервала, т.е.
******12349876
където интервалът е означен със знака *.
Операторът
cout << setw(10) << i << setw(10) << j << “\n”;
извежда
******1234******9876

Манипулатори dec, oct и hex

Целите числа се извеждаt в десетична позиционна система. Ако се налага изходът им да е в осмична или шестнадесетична позиционна система, се използват манипулаторите oct и hex съответно. Всеки от тях е в сила, докато друг манипулатор за позиционна система не е указан за следващ извод. Връщането към десетична позиционна система се осъществява чрез манипулатора dec.

dec – манипулатор, задаващ всички следващи изходи (докато не е указан друг манипулатор, променящ позиционната система) на цели числа да са в десетична позиционна система;

oct – манипулатор, задаващ всички следващи изходи (докато не е указан друг манипулатор, променящ позиционната система) на цели числа да са в осмиична позиционна система;

hex - манипулатор, задаващ всички следващи изходи (докато не е указан друг манипулатор, променящ позиционната система) на цели числа да са в шестнадесетична позиционна система.

Пример: Нека имаме
ОП
i j
23
След изпълнението на операторите
cout << setw(10) << dec << i << setw(10) << j << “\n”;
cout << setw(10) << oct << i << setw(10) << j << “\n”;
cout << setw(10) << hex << i << setw(10) << j << “\n”;
имаме:
********12********23
********14********27
*********c********17
Забележка: Преди използване на манипулаторите е необходимо да се включи заглавният файл iomanip.h, т.е. в частта за заглавни файлове да се запише директивата
#include <iomanip.h>

Други целочислени типове

Други цели типове се получават от int като се използват модификаторите short, long, signed и unsigned. Тези модификатори доопределят някои аспекти на типа int.
За реализацията Visual C++ 6.0 са в сила:

Тип Диапазон Необходима памет
short int -32768 до 32767 2 байта
unsigned short int 0 до 65535 2 байта
long int -2147483648 до 2147483647 4 байта
unsigned long int 0 до 4294967295 4 байта
unsigned int 0 до 4294967295 4 байта

Запазената дума int при тези типове се подразбира и може да бъде пропусната. Типовете short int (или само short) и long int (или само long) са съкратен запис на signed short int и signed long int.

[ivakavlad]

3.2.2. Реални типове

Ще разгледаме реалния тип double.
Типът е стандартен, вграден във всички реализации на езика.

Множество от стойности

Множеството от стойности на типа double се състои от реалните числа от -1.74*10308 до 1.7*10308 . Записват се във два формата – като числа с фиксирана и като числа с плаваща запетая (експоненциален формат).

<реално_число> ::= <цяло_число>.<цяло_число_без_ знак>|
<цяло_число>Е<порядък> |
<цяло_число>.<цяло_число_без_ знак>E<порядък> |
<порядък> ::= <цяло_число>
При експоненциалния формат може да се използва и малката латинска буква e.
Примери: Следните числа
123.3454 -10343.034 123Е13 -1.23е-4
са коректно записани реални числа.
Смисълът на експоненциалния формат е реално число, получено след умножаване на числото пред E (e) с 10 на степен числото след E (e).
Примери: 12.5Е4 е реалното число 125000.0, а –1234.025е-3 е реалното число –1.234025.
Елементите от множеството от стойности на типа double се наричат реални константи или по-точно константи от реалния тип double.
Променлива величина, множеството от допустимите стойности, на която съвпада с множеството от стойности на типа double, се нарича реална променлива или променлива от тип double.
Дефинира се по обичайния начин. Дефиницията свързва реалните променливи с множеството от стойности на типа double или с конкретна стойност от това множество, като отделя по 8 байта оперативна памет за всяка от тях. Ако променливата не е била инициализирана, съдържанието на свързната с нея памет е неопределено, а в противен случай – съдържа указаната при инициализацията стойност.
Примери:
double i;
double j = 5699.876;
След тази дефиниция, имаме:
ОП
i j
- 5699.876
8 байта 8 байта

Операции и вградени функции

Аритметични операции

Унарни операции

+, - Префиксни са. Потвърждават или променят знака на
аргумента си.
Примери: Нека
double i = 1.2, j = -7.5;
Следните конструкции съдържат унарна операция + или -:
-i +j -j +i -56.7

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

Имат два аргумента. Следните аритметичните оператори са инфиксни:

+ - събиране
- - изваждане
* - умножение
/ - деление (поне единият аргумент е реален)

Примери:
15.3 – 12.2 = 3.1 13.0 / 5 = 2.6
15 + 12.35 = 27.35 13 / 5.0 = 2.6
-1.5 * 12.3 = -18.45

Логически операции

Логическите операции конюнкция, дизюнкция и отрицание могат да се прилагат над реални константи. Дефинират се по същия начин, като реалните числа, които са различни от 0.0 се интерпретират като true, а 0.0 – като false.
Примери:
123.6 and 0.0 е false
0.0 or 15.67 е true
not 67.7 е false

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

Над реални данни могат да се извършват следните инфиксни операции за сравнение:
== - за равно != - за различно
> - за по-голямо >= - за по-голямо или равно
< - за по-малко <= - за по-малко или равно.
Наредбата на реалните числа е като в математиката.
Примери:
123.56 < 234.09 е true
-123456.9888 > 324.0098 е false
23451.6 >= 0 е true

Допълнение: Сравнението за равно на две реални числа x и y се реализира обикновено чрез релацията: |x – y| < e, където e = 10-14 за тип double. По-добър начин е да се използва релацията:


Вградени функции

При цял или реален аргумент, следните функции връщат реален резултат от тип double:
Sin(x) - синус, sin x, x е в радиани
cos(x) - косинус, cos x, x е в радиани
tan(x) - тангенс, tg x, x е в радиани
аSin(x) - аркуссинус, arcsin x

[ivakavlad]

3.2.3. Аритметични изрази

Аритметичните изрази са правила за получаване на числови константи. Има два вида аритметични изрази: цели и реални.

<аритметичен_израз> ::= <цял_израз> | <реален_израз>

Цели аритметични изрази

Целите аритметични изрази са правила за получаване на константи от тип int или разновидностите му. Дефинират се рекурсивно по следния начин:

Целите константи са цели аритметични изрази.
Примери: 123 –2345 –32767
0 22233345 –87
са цели аритметични изрази.

Целите променливи са цели аритметични изрази.
Примери: Ако имаме дефиницията:
int i, j;
short p, q, r;
i j
са цели аритметични изрази от тип int, a
p q r
са цели аритметични изрази от тип short.

- Прилагането на унарните операции + и – към цели аритметични изрази е цял аритметичен израз.
Примери: -i +j -j
са цели аритметични изрази от тип int, а
+p -p +r -q
са цели аритметични изрази от тип short.

- Прилагането на бинарните аритметични операции +, -, *, / и % към цели аритметични изрази, е цял аритметичен израз.
Пример: i % 10 + j * i - p -i + j / 5
са цели аритметични изрази от тип int,
r – p / 12 – q r % q – p r + p – q
са цели аритметични изрази от тип short.

- Цели функции, приложени над цели аритметични изрази, са цели аритметични изрази.
Примери: abs(i+j) е цял аритметичен израз от тил int, а abs(p-r) е цял аритметичен израз от тип short.

Реални аритметични изрази

Реалните аритметични изрази са правила за получаване на константа от тип double или float. Дефинират се рекурсивно по следния начин:

Реалните константи са реални аритметични изрази.
Примери: 1.23е-3 –2345е2 –3.2767 0.0
222.33345 –8.7009
са реални аритметични изрази.
Забележка: Реална константа от диапазона на тип float, но с повече от 7 значещи цифри се приема от компилатора за реално число от тип double.

Реалните променливи са реални аритметични изрази.
Примери: Ако имаме дефинициите:
double i, j;
float p, q, r;
i j
са реални аритметични изрази от тип double, a
p q r
са реални аритметични изрази от тип float.

- Прилагането на унарните операции + и – към реални аритметични изрази е реален аритметичен израз.
Примери: -i +j -j
са реални аритметични изрази от тип double, а
+p -p +r -q
са реални аритметични изрази от тип float.

- Прилагането на бинарните аритметични операции +, -, * и / към аритметични изрази, поне един от които е реален, е реален аритметичен израз.
Пример: i % 10 + j*i - p -i + j/5
са реални аритметични изрази от тип double, а
–p/12 – q r%q – p r + p – q
са реални аритметични изрази от тип float.

- Реални функции, приложени над реални или цели аритметични изрази, са реални аритметични изрази.
Примери: fabs(i+j) sin(i-p) cos(p/r-q) floor(p)
ceil(r-p+i) exp(p) log(r-p*q)
са реални аритметични изрази от тип double.

Семантика на аритметичните изрази

За пресмятане на стойностите на аритметичните изрази се използват следният приоритет на операциите и вградените функции:
1. Вградени функции
2. Действията в скобите
3. Операции в следния приоритет
- +, - (унарни) най-висок
- *, /, %
- +, - (бинарни)
- <<, >> най-нисък
Забележка 1: Операторите >> и << са за побитови измествания надясно и наляво съответно. Те са предефинирани за входно/изходни операции. В случая имаме предвид тази тяхна употреба.
Забележка 2: Инфиксните операции, които са разположени на един и същ ред са с еднакъв приоритет. Тези оператори се изпълняват отляво надясно. Унарните операции се изпълняват отдясно наляво.
Пример: Нека имаме дефиницията
double x = 23.56, y = -123.5;
Изпълнението на оператора
cout << sin(x) + ceil(y) * x – cos(y);
ще се извърши по следния начин: отначало ще се пресметнат стойностите на sin(x), ceil(y) и cos(y), след това ще изпълни операцията * над стойността на ceil(y) и x, полученото ще събере със стойността на sin(x), след което от полученото реално число ще се извади пресметнатата вече стойност на cos(y). Накрая върху екрана ще се изведе получената реална константа.
Аритметичните изрази могат да съдържат операнди от различни типове. За да се пресметне стойността на такъв израз, автоматично се извършва преобразуване на типовете на операндите му. Без загуба на точността се осъществяват следните преобразувания:
Тип Преобразува се до тип
bool всички числови типове
short int
unsigned short unsigned int
float double

т.е.конвертира се от “по-малък” тип (в байтове) към “по-голям” тип.
За да се пресметне стойността на аритметичен израз с операнди от различни типове, последователно се прилагат правилата по-долу, докато се уеднаквят типовете (ако е възможно).
Ако има операнд от тип: Другите операнди се преобразуват до:
double double
float float
unsigned int unsigned int
int int
unsigned short unsigned short
short short


Семантика на булевите изрази

Булевите изрази са правила за получаване на булева стойност. За пресмятане на стойностите им се използва следният приоритет на операциите и вградените функции:
1. Вградени функции
2. Действията в скобите
3. Операции в следния приоритет
- !, not, +, - (унарни) най-висок
- *, /, %
- +, - (бинарни)
>> << (вход/изход)
<, <=, >, >=
==, !=
&&
|| най-нисък

Забележка: Инфиксните операции, които са разположени на един и същ ред са с еднакъв приоритет. Тези оператори се изпълняват отляво надясно, т.е. лявоасоциативни са. Унарните оператори се изпълняват отдясно наляво, т.е. дясноасоциативни са.
Примери: а) Нека имаме дефинициите:
double x = 23.56, y = -123.5;
bool b1, b2, b3;
b1 = true;
b2 = !b1;
b3 = b1||b2;
Изпълнението на оператора
cout << sin(x) + ceil(y) * x > 12398;
ще сигнализира грешка – некоректни аргументи на <<. Това е така, заради нарушения приоритет. Операторът << е с по-висок приоритет от този на операторите за сравнение. Налага се вторият аргумент на << да бъде ограден в скоби, т.е.операторът
cout << (sin(x) + ceil(y) * x > 1239;
вече работи добре.
б) Изпълнението на оператора
cout << b1 && b2 || b3 << “\n”;
също съобщава грешка – некоректни аргументи на <<. Отново е нарушен приоритетът на операциите. Налага се аргументът b1 && b2 || b3 на << да се огради в скоби, т.е.
cout << (b1 && b2 || b3) << “\n”;
вече работи добре.

Задачи върху типовете булев, цял и реален

Задача 5. Кои от следните редици от знаци са числа в C++?
а) 061 б) –31 в) 1/5 г) +910.009
д) VII е) 0.(3) ж) sin(0) з) 134+12
Решение: а), б), г).
Задача 6. Да се запишат на C++ следните числа:
а) 6! б) LXXIV в) –0,4(6) г) 138,2(3
д) 11/4 е) p ж) 1,2 .10-1 з) –23,(1) .102
В дробната част да се укажат до 4 цифри.
Решение:
а) 120 б) 74 в) –0.4667 г) 138.2384
д) 2.7500 е) 3.1416 ж) 0.1200 з) –2311.1111
Задача 7. Да се запишат на езика C++ следните математически формули:


а) a + b.c – a2b3c4


Решение:
a) a + b * c – a * a * b * b * b * c * c * c * c
б) (a * b) / c + c / (a * b)
в) (1 + x + x*x/2)*(1 + x*x*x/6 + x*x*x*x*x/120)
или
(1 + x + pow(x,2))/(1 + pow(x, 3)/6 + pow(x, 5)/120)
г) sqrt(1 + sqrt(2 + sqrt(3 + sqrt(4))))
Задача 8. Какво ще бъде изведено след изпълнението на следната програма:
#include <iostream.h>
#include <math.h>
int main()
{ cout << "x=";
double x;
cin >>x;
bool b;
b = x < ceil(x);
cout << "x=";
cin >> x;
b = b && (x < floor(x));
cout << "b= " << b << "\n";
return 0;
}
ако като вход бъдат зададени числата
a) 2.7 и 0.8 б) 2.7 и –0.8 в) –2.7 и –0.8.
Решение: а) ТЪй като булевият израз 2.7 < ceil(2.7) има стойност true, а true && (0.8 < floor(0.) - е false, ще бъде изведено 0 (false).
Задача 9. Какъв ще е резултатът от изпълнението на програмата
#include <iostream.h>
int main()
{int a, b;
cin >> a >> b >> a >> b >> a;
cout << a << " " << b << " "
<< a << " " << b << " "
<< a << "\n";
return 0;
}
ако като вход са зададени числата 1, 2, 3, 4 и 5?
Решение: След обработката на дефиницията int a, b; за променливите a и b са отделени по 4 байта ОП, т.е.
ОП
а b
- -
а след изпълнението на оператора за четене >>, a и b получават отначало стойностите 1 и 2. След това стойностите им се променят на 3 и 4 съответно. Най-накрая a става 5, т,е,
a b
5 4
Тогава програмата извежда
5 4 5 4 5
Задача 10. Да се запише булев израз, който има стойност true, ако посоченото условие е в сила, и стойност false, ако условието не е в сила.
а) цялото число a се дели на 5;
б) точката x принадлежи на отсечката [2, 6];
в) точката x не принадлежи на отсечката [2, 6];
г) точката x принадлежи на отсечката [2, 6] или на отсечката [-4, -2];
д) поне едно от числата a, b и c е отрицателно;
е) числата a, b и c са равни помежду си.
Решение:
a % 5 == 0
б) x >= 2 && x <= 6
в) x < 2 || x > 6 или !( x >= 2 && x <= 6)
г) x >= 2 && x <= 6 || x >= -4 && x <= -2
е) a == b && a == c

Задача 11. Да се напише програма, която въвежда координатите на точка от равнината и извежда 1, ако точката принадлежи на фигурата по-долу и – 0, в противен случай.
y
2




-2 -1 0 1 2
x






-2


Решение:
#include <iostream.h>
#include <math.h>
int main()
{cout << "x= ";
double x;
cin >> x;
cout << "y= ";
double y;
cin >> y;
bool b1 = x*x + y*y <= 4 && y >= 0;
bool b2 = fabs(x) <= 1 && y < 0 && y >= -2;
cout << (b1 || b2) << "\n";
return 0;
}


Задачи


Задача 1. Да се запишат на езика C++ следните математически формули:







Задача 2. Кои от следните редици от символи са правилно записани изрази на езика C++:
а) 1 + |y| г) 1 + sqrt(sin((u+v)/10))
б) -abs(x) + sin z д) -6 + xy
в) abs(x) + cos(abs(y - 1.7)) е) 1/-2 + Beta.

Задача 3. Да се запишат в традиционна (математическа) форма следните изрази, записани в синтаксиса на езика C++:
а) sqrt(a+b) - sqrt(a-b) в) x*y/(u+v)-(u-v)/y*(a+b)
б) a + b/(c+d)-(a+b)/c+d г) 1+exp(cos((x+y)/2)).

Задача 4. Да се пресметне стойността на израза:
а) cos(0) + abs(1/(1/3-1))
б) abs(a-10) + sin(a-1), за a = 1;
в) cos(-2+2*x) +sqrt(fabs(x-5)), за x = 1;
г) sin(sin(x*x-1)*sin(x*x-1)) + cos(x*x*x-1)*abs(x-2),
за x = 1;
д) sin(sin(x*x-1))+cos(x*x*x-1)*cos(abs(x-2)-1)/y*a +
sqrt(abs(y)-x), за x = 1, y = -2, a = 2.

Задача 5. В аритметичния израз
а) a/b*c/d*е/f*h
б) a+b/x-2*y
в) a+b/x-2*y


да се поставят скоби така, че полученият израз да съответствува на математическата формула:


Задача 6. Да се напише израз на езика C++, който да изразява:
а) периметърa на квадрат с лице, равно на a;
б) лицето на равностранен триъгълник с периметър, равен на p.


Задача 7. Да се напише програма, която пресмята стойността на v1, където


Задача 8. Да се пресметне стойността на израза:
a) pow(x, 2) + pow(y, 2) <= 4 при x = 0.6, y = -1.2
б) p % 7 == p / 5 - 2 при p = 15
в) floor(10*k+16.3)/2 == 0 при k = 0.185
г) !((k+325)%2 == 1) при k = 28
д) u*v != 0 && v > u при u = 2, v = 1
е) x || !y при x = false, y = true.

Задача 9. Да се запише булев израз, който да има стойност истина, ако посоченото условие е вярно и стойност - лъжа, ако условието не е вярно:
а) цялото число p се дели на 4 или на 7;
б) уравнението a.x2 + b.x + c = 0 (a ≠ 0) няма реални корени;
в) точка с координати (a, b) лежи във вътрешността на кръг с радиус 5 и център (0, 1).
г) точка с координати (a, b) лежи извън кръга с център (c, d) и радиус f;
д) точка принадлежи на частта от кръга с център (0, 0) и радиус 5 в трети квадрант;
е) точка принадлежи на венеца с център (0, 0) и радиуси 5 и 10;
ж) x принадлежи на отсечката [0, 1];
з) x = max{a, b, c}
и) x != max{a, b, c} (операцията ! да не се използва);
к) поне една от булевите променливи x и y има стойност true;
л) и двете булеви променливи x и y имат стойност true;
м) нито едно от числата a, b и c е положително;
н) цифрата 7 влиза в записа на положителното трицифрено число p;
о) цифрите на трицифреното число m са различни;
п) поне две от цифрите на трицифреното число m са равни помежду си.

Допълнителна литература

К. Хорстман, Принципи на програмирането със C++, С., СОФТЕХ, 2000.
П. Лукас, Наръчник на програмиста, С., Техника, 1994.
Ст. Липман, Езикът C++ в примери, “КОЛХИДА ТРЕЙД” КООП, С. 1993.

[ivakavlad]

Глава 3

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


В тази глава ще разгледаме управляващите оператори в езика. Ще ги наричаме само оператори.

4.1. Oператор за присвояване

Това е един от най-важните оператори на езика. Вече многократно го използвахме, а също в глава 2 описахме неговите синтаксис и семантика. В тази глава ще го разгледаме по-подробно. Ще напомним неговите синтаксис и семантика.
Синтаксис
<променлива> = <израз>;
- където <променлива> е идентификатор, дефиниран вече като променлива,
- <израз> е израз от тип, съвместим с типа на <променлива>.
Семантика
Намира се стойността на <израз>. Ако тя е от тип, различен от типа на <променлива>, конвертира се ако е възможно до него и се записва в именуваната с <променлива> памет.

• Ако <променлива> е от тип <bool>, <израз> може да бъде от тип bool или от кой да е числов тип.
• Ако <променлива> е от тип double, всички числови типове, а също типът bool, могат да са типове на <израз>.
• Ако <променлива> е от тип float, типовете float, short, unsiged short и bool, могат да са типове на <израз>. Ако <израз> е от тип int, unsigned int или double, присвояването може да се извърши със загуба на точност. Компилаторът предупреждава за това.
• Ако <променлива> е от тип int, типовете int, long int, short int и bool, могат да са типове на <израз>. В този случай ако <израз> е от тип double или float, дробната част на стойността на <израз> ще бъде отрязана и ако полученото цяло е извън множеството от стойности на типа int, ще се получи случаен резултат. Компилаторът издава предупреждение за това.
• Ако <променлива> е от тип short int, типовете short int и bool, могат да са типове на <израз>. В противен случай се извършват преобразувания, които водят до загуба на точност или даже до случайни резултати. Много компилатори не предупреждават за това.

Ще отбележим, че в рамките на една функция не са възможни две дефиниции на една и съща променлива, но на една и съща променлива може да й бъдат присвоявани многократно различни стойности.
Пример: Не са допустими
…
double a = 1.5;
…
double a = a + 5.1;
…
но са допустими присвояванията:
…
double a = 1.5;
…
a = a + 34.5;
…
a = 0.5 + sin(a);
…
В езика C++ са въведени някои съкратени форми на оператора за присвояване. Например, заради честото използване на оператора:
a = a + 1;
той съкратено се означава с
a++;
Въведено е също и съкращението a-- на оператора a = a-1;
В същност ++ и -- са реализирани като постфиксни унарни оператори увеличаващи съответно намаляващи аргумента си с 1. Приоритетът им е един и същ с този на унарните оператори +, - и !.
Забележка: От оператора ++, за добавяне на 1, идва името на езика C++ - вариант на езика C, към който са добавени много подобрения и нови черти.
Допълнение: Операторът за присвояване = е претоварен и с функцията на дясноасоциативна инфиксна аритметично-логическа операция с приоритет по-нисък от този на дизюнкцията ||. Това позволява на оператора за присвояване
X = y;
където x е променлива, а y – израз, да се гледа като на израз от тип – типа на x и стойност – стойността на y, ако е от типа на x или стойността на y, но преобразувана до типа на x.
Пример: Програмата
#include <iostream.h>
int main()
{int a;
double b;
b = 3.2342;
cout << (a = b) << "\n";
return 0;
}
е допустима. Резултът от изпълнението й е 3, като компилаторът издава предупреждение за загуба на информация при преобразуването от тип double в тип int. Изразът a = b е от тип int и има стойност 3. Ограждането му в скоби е необходимо заради по-ниския приоритет на = от този на <<.
Допълнение: Допустим е операторът:
X = y = 5;
Тъй като = е дясноасоциативен, отначало променливата y се свързва със 5, което е стойността на израза y = 5. След това x се свързва с 5, което е стойността на целия израз.
Някои компилатори издават предупреждение при тази употреба на оператора =. Затова не препоръчваме да се използва = като аритметичен оператор.

Задачи върху оператора за присвояване

Задача 12. Нека са дадени дефинициите
double x, y, z;
int m, n, p;
Кои от следните редици от символи са оператори за присвояване:
а) -x = y; б) x = -y; в) m + n = p;
г) p = x + y; д) z = x - y е) z = m + n;
ж) sin(0) = 0; з) x n + sin(z) к) 4 = sin(p + 5)?

В случаите а), в), ж) и к) редиците не са оператори за присвояване, тъй като на израз се присвоява израз. В случай г) редицата от символи е оператор за присвояване, но тъй като на цяла променлива се присвоява стойността на реален израз, компилаторът ще направи предупреждение за загуба на точност, а в случай з) е пропуснат символът '=' от знака за присвояване.

Задача 13. Да се напише програма, която въвежда стойности на реалните променливи a и b, след което разменя и извежда стойностите им (Например, ако a = 5.6, а b = -3.4, след изпълнението на програмата a да става -3.4 , а b да получава стойността 5.6).

Програма Zad13.cpp решава задачата.
Program Zad13.cpp
#include <iostream.h>
int main()
{cout << "a= ";
double a;
cin >> a;
cout << "b= ";
double b;
cin >> b;
double x;
x = a;
a = b;
b = x;
cout << "a= " << a << "\n";
cout << "b =" << b << "\n";
return 0;
}
В тази програма се използва работна променлива x, която съхранява първоначалната стойност на променливата a.

Задача 14. Да се напише програма, която въвежда положително трицифрено число и извежда на отделни редове цифрите на стотиците, на десетиците и на единиците на числото.

Програма Zad14.cpp решава задачата.
Program Zad14.cpp
#include <iostream.h>
#include <iomanip.h>
int main()
{ cout << "a – three-digit, integer and positive? ";
int a ;
cin >> a;
short s, d, e;
s = a / 100;
d = a / 10 % 10;
e = a % 10;
cout << setw(10) << "stotici: " << setw(5) << s << "\n";
cout << setw(10) << "desetici:" << setw(5) << d << "\n";
cout << setw(10) << "edinici: " << setw(5) << e << "\n";
return 0;
}

Задача 15. На цялата променлива b да се присвои първата цифра на дробната част на положителното реално число x (Например, ако x = 52.467, то b = 4).

Програма Zad15.cpp решава задачата
Program Zad15.cpp
#include<iostream.h>
#include <math.h>
int main()
{ cout << "x>0? ";
double x;
cin >> x;
int i = floor(x * 10);
int b = i % 10;
cout << x << "\n";
cout << b << "\n";
return 0;
}

Задача 16. Да се напише програма, която извежда 1, ако в записа на положителното четирицифрено число a, всички цифри са различни и 0 - в противен случай.

Програма Zad16.cpp решава задачата.
Program Zad20.cpp
#include <iostream.h>
int main()
{ cout << "a - four-digit, integer and positive? ";
int a ;
cin >> a;
short h, s, d, e;
h = a / 1000;
s = a / 100 % 10;
d = a / 10 % 10;
e = a % 10;
cout << (h != s && h != d && h != e &&
s != d && s != e && d != e) << "\n";
return 0;
}

[ivakavlad]

4.2. Празен оператор

Това е най-простия оператор на C++. Описанието му е дадено на Фиг. 1.

Синтаксис
;
Операторът не съдържа никакви символи. Завършва със знака ;.
Семантика
Не извършва никакви действия. Използва се когато синтаксисът на някакъв оператор изисква присъствието на поне един оператор, а логиката на програмата не изисква такъв.


Фиг. 1.

Забележка: Излишни празни оператори не предизвикват грешка при компилация. Например, редицата от оператори
a = 150;;;
b = 50;;;;
c = a + b;;
се състои от: оператора за присвояване a = 150, 2 празни оператора, оператора за присвояване b = 50, 3 празни оператора, оператора за присвояване c = a + b и 1 празен оператор и е напълно допустим програмен фрагмент.
Други примери ще дадем по-късно.

4.3. Блок

Често синтаксисът на някакъв оператор на езика изисква използването на един оператор, а логиката на задачата – редица от оператори. В този случай се налага оформянето на блок (Фиг. 2.).

Синтаксис
{ <оператор1>
<оператор2>
. . .
<операторn>
}
Семантика
Обединява няколко оператора в един, наречен блок. Може да бъде поставен навсякъде, където по синтаксис стои оператор.
Дефинициите в блока, се отнасят само за него, т.е. не могат да се използват извън него.

Фиг. 2.
Пример: Операторът
{cout << “a= “;
double a;
cin >> a;
cout << “b= “;
double b;
cin >> b;
double c = (a+b)/2;
cout << “average{a, b} = “ << c << “\n”;
}
е блок. Опитът за използване на променливите a, b и c след блока, предизвиква грешка.
Препоръка: Двойката фигурни скобки, отварящи и затварящи блока да се поставят една под друга.
Забележка: За разлика от другите оператори, блокът не завършва със знака ;.

4.4. Условни оператори

Чрез тези оператори се реализират разклоняващи се изчислителни процеси. Оператор, който дава възможност да се изпълни (или не) един или друг оператор в зависимост от някакво условие, се нарича условен. Ще разгледаме следните условни оператори: if, if/else и switch.

[ivakavlad]

4.4.1. Условен оператор if

Чрез този условен оператор се реализира разклоняващ се изчислителен процес от вид, илюстриран на Фиг. 3.


не


да





Фиг. 3.

Ако указаното условие е в сила, изпълняват се определени действия, а ако не – тези действия се прескачат. И в двата случая след това се изпълняват общи действия.
Условието се задава чрез някакъв булев израз, а действията – чрез оператор. Фиг. 4 описва подробно синтаксиса и семантиката на този оператор.


Синтаксис
if (<условие>) <оператор>
където
- if (ако) е запазена дума
- <условие> е булев израз;
- <оператор> е произволен оператор.
Семантика
Пресмята се стойността на булевия израз, представящ условието. Ако резултатът е true, изпълнява се <оператор>. В противен случай <оператор> не се изпълнява, т.е.

false

true
if (<условие>) <оператор>


…

Фиг. 4.

Забележки:
1. Булевият израз, определящ <условие>, трябва да бъде определен. Огражда се в кръгли скобки.
2. Операторът след условието е точно един. Ако е необходимо няколко оператора да се изпълнят, трябва да се обединят в блок.

Задача 17. Да се напише програма, която намира май-малкото от три дадени реални числа.

Ще реализираме следните стъпки:
а) Въвеждане на стойности на реалните променливи a, b и c.
б) Инициализиране със стойността на a на работна реална променлива min, която ще играе и ролята на изходна променлива.
в) Сравняване на b с min. Ако стойността на b е по-малка от запомнения в min текущ минимум, запомня се b в min. В противен случай, min не се променя. Така min съдържа min{a, b}.
г) Сравняване на c с min. Ако стойността на c е по-малка от запомнения в min текущ минимум, c се запомня в min. В противен случай, min не се променя. Така min съдържа min{a, b, c}.
д) Извеждане на резултата – стойността на min.

Програма Zad17.cpp реализира този алгоритъм.
Program Zad17.cpp
#include <iostream.h>
int main()
{cout << "a= ";
double a;
cin >> a;
cout << "b= ";
double b;
cin >> b;
cout << "c= ";
double c;
cin >> c;
double min = a;
if (b < min) min = b;
if (c < min) min = c;
cout << "min{" << a << ", " << b << ", "
<< c << "}= " << min << "\n";
return 0;
}
Ако вместо очаквано реално число, при въвеждане на стойности за променливите a, b и c, се въведе произволен низ, не представляващ число, буферът на клавиатурата, свързан със cin ще изпадне в състояние fail, а обектът cin ще има стойност false. Добрият стил за програмиране изисква в такъв случай програмата да прекъсне изпълнението си с подходящо съобщение за грешка. Програмата от задача 18 реализира този стил.

Задача 18. Да се напише програма, която намира най-малкото от три дадени реални числа. Програмата да извършва проверка за коректност на входните данни.

Програма Zad18.cpp решава задачата.
Program Zad18.cpp
#include <iostream.h>
int main()
{cout << "a= ";
double a;
cin >> a;
if (!cin)
{cout << "Error, bad input \n";
return 1;
}
cout << "b= ";
double b;
cin >> b;
if (!cin)
{cout << "Error, bad input \n";
return 1;
}
cout << "c= ";
double c;
cin >> c;
if (!cin)
{cout << "Error, bad input \n";
return 1;
}
double min = a;
if (b < min) min = b;
if (c < min) min = c;
cout << "min{" << a << ", " << b << ", "
<< c << "}= " << min << "\n";
return 0;
}
Ще напомним, че операторът return предизвиква преустановяване работата на програмата, а стойността 1 – че е възникнала грешка.

Задача 19. Да се сортира във възходящ ред редица от три реални числа, запомнени в променливите a, b и c.

Ще реализираме следните стъпки:
а) Въвеждане на стойности за a, b и c.
б) Сравняване на стойностите на a и b. Ако е в сила релацията b<a, извършва се размяна на стойностите на a и b. В противен случай – размяната не се извършва.
в) Сравняване на стойностите на a и c. Ако е в сила релацията c<a, извършва се размяна на стойностите на a и c. В противен случай – размяната не се извършва. След това действие, променливата a съдържа най-малката стойност на редицата.
г) Сравняване на стойностите на b и c. Ако е в сила релацията c<b, извършва се размяна на стойностите на b и c. В противен случай – размяната не се извършва.
е) Извеждане на стойностите на a, b, и c.

Програма Zad19.cpp реализира това описание.
Program Zad19.cpp
#include <iostream.h>
#include <iomanip.h>
int main()
{ cout << "a= ";
double a;
cin >> a;
if (!cin)
{cout << "Error, bad input \n";
return 1;
}
cout << "b= ";
double b;
cin >> b;
if (!cin)
{cout << "Error, bad input \n";
return 1;
}
cout << "c= ";
double c;
cin >> c;
if (!cin)
{cout << "Error, bad input \n";
return 1;
}
if (b < a) {double x = a; a = b; b = x;}
if (c < a) {double x = c; c = a; a = x;}
if (c < b) {double x = c; c = b; b = x;}
cout << setprecision(2) << setiosflags(ios :: fixed);
cout << setw(10) << a << setw(10) << b << setw(10)
<< c << "\n";
return 0;
}
Забележка: Променливата x е видима (може да се използва) само в блоковете, където е дефинирана.

[ivakavlad]

4.4.2. Оператор if/else

Операторът се използва за избор на една от две възможни алтернативи в зависимост от стойността на дадено условие.
Чрез него се реализира разклоняващ се изчислителен процес от вид, илюстриран на Фиг. 5.


не


да





Фиг. 5.

Ако указаното условие е в сила, се изпълняват се едни действия, а ако не – други действия. И в двата случая след това се изпълняват общи действия.
Условието се задава чрез някакъв булев израз, а действия 1 и действия 2 – чрез оператори. Фиг. 6 описва подробно синтаксиса и семантиката на този оператор.


Синтаксис
if (<условие>) <оператор1> else <оператор2>
където
- if (ако) и else (иначе) са запазени думи
- <оператор1> и <оператор2> са произволни оператори;
- <условие> е булев израз.
Семантика
Пресмята се стойността на булевия израз, представящ условието. Ако резултатът е true, изпълнява се <оператор1>. В противен случай се изпълнява <оператор2>, т.е.

false
true
if (<условие>) <оператор1> else <оператор2>


…

Фиг. 6.

Забележки:
1. Булевият израз, определящ <условие>, трябва да бъде напълно определен. Задължително се огражда в кръгли скобки.
2. Операторът след условието е точно един. Ако е необходимо няколко оператора да се изпълнят, трябва да се обединят в блок.
3. Операторът след else е точно един. Ако е необходимо няколко оператора да се изпълнят, трябва да се обединят в блок.


Задача 20. Променливата y зависи от променливата x. Зависимостта е следната:
Да се напише програма, която по дадено x намира съответната стойност на y.

Програма Zad20.cpp решава задачата.
Program Zad20.cpp
#include <iostream.h>
#include <iomanip.h>
#include <math.h>
int main()
{ cout << "x= ";
double x;
cin >> x;
if (!cin)
{cout << "Error, bad input!!! \n";
return 1;
}
double y;
if (x >= 1) y = log10(x) + 1.82;
else y = x*x - 7*x + 8.82;
cout << setprecision(3) << setiosflags(ios :: fixed);
cout << setw(10) << x << setw(10) << y << "\n";
return 0;
}
След въвеждането на стойността на променливата x, програмата извършва проверка за валидност на въведената стойност. Изпълнението на оператора if/else води до пресмятане на стойността на булевия израз x >= 1. Ако тя е true, се изпълнява операторът за присвояване y = log10(x) + 1.82;. В противен случай се изпълнява операторът за присвояване y = x*x - 7*x + 8.82;, след което се извежда резултатът.

Вложени условни оператори

В условните оператори:
if (<условие>) <оператор>
if (<условие>) <оператор1> else <оператор2>
<оператор>, <оператор1> и <оператор2> са произволни оператори, в т. число могат да бъдат условни оператори. В този случай имаме вложени условни оператори.
При влагането е възможно да възникнат двусмислици. Ако в един условен оператор има повече запазени думи if отколкото else, възниква въпросът, за кой от операторите if се отнася съответното else. Например, нека разгледаме оператора
if (x >= 0) if ( x >= 5) x = 1/x; else x = -x;
Възможни са следните две различни тълкувания на този оператор:
а) if оператор, тялото на който е if/else оператор, т.е.
if (x >= 0)
if (x >= 5) x = 1/x; else x = -x;
При това тълкувание, ако преди изпълнението на if оператора x има стойност –5, след изпълнението му, стойността на x остава непроменена.
б) if/else оператор, с if оператор след <условие>, т.е.
if (x >= 0) if ( x >= 5) x = 1/x;
else x = -x;
При това тълкувание, ако преди изпълнението на if/else оператора x има стойност –5, след изпълнението му, стойността на x става 5.
Записът чрез съответни подравнявания, не влияе на компилатора. В езика C++ има правило, което определя начина по който се изпълняват вложени условни оператори.


Правило: Всяко else се съчетава в един условен оператор с най-близкото преди него несъчетано if. Текстът се гледа отляво надясно.


Според това правило, компилаторът на C++ ще приеме първото тълкувание за горните вложени условни оператори.
Препоръка: Условен оператор да се влага в друг условен оператор само след else. Ако се налага да се вложи след условието, вложеният условен оператор да се направи блок.

Задачи върху операторите if и if/else

Задача 21. Ако променливата a има стойност 8, определете каква стойност ще има променливата b след изпълнението на оператора
if (a > 4) b = 5; else
if (a < 4) b = -5; else
if (a == b = 8; else b = 3;

Тъй като е в сила условието a > 4, променливата b ще получи стойността 5.

Задача 22. Стойността на y зависи от x. Зависимостта е следната:

Да се напише програма, която по дадено x, намира стойността на y.

Програма Zad22.cpp решава задачата.
Program Zad22.cpp
#include <iostream.h>
#include <iomanip.h>
int main()
{ cout << "x= ";
double x;
cin >> x;
if (!cin)
{ cout << "Error, Bad input\n";
return 1;
}
double y;
if (x <= 2) y = x; else
if (x <= 3) y = 2; else y = x-1;
cout << setprecision(3) << setiosflags(ios :: fixed);
cout << setw(10) << x << setw(10) << y << "\n";
return 0;
}
Забележка: В програма Zad22.cpp след първото else е в сила условието x > 2. Затова не е нужно то да се проверява.

Задача 23. Да се напише програма, която въвежда три реални числа a, b и c и извежда 0, ако не съществува триъгълник със страни a, b и c. Ако такъв триъгълник съществува, да извежда 3, 2 или 1 в зависимост от това какъв е триъгълникът - равностранен, равнобедрен или разностранен съответно.

Програма Zad23.cpp решава задачата.
Program Zad23.cpp
#include <iostream.h>
int main()
{ cout << "a= ";
double a;
cin >> a;
if (!cin)
{cout << "Error, bad input \n";
return 1;
}
cout << "b= ";
double b;
cin >> b;
if (!cin)
{cout << "Error, bad input \n";
return 1;
}
cout << "c= ";
double c;
cin >> c;
if (!cin)
{cout << "Error, bad input \n";
return 1;
}
bool x = a <= 0 || b <= 0 || c <= 0 ||
a+b <= c || a+c <= b || b+c <= a;
if (x) cout << 0 << "\n"; else
if (a == b && b == c) cout << 3 << "\n"; else
if (a == b || a == c || b == c) cout << 2 << "\n"; else
cout << 1 << "\n";
return 0;
}
Булевата променлива x е помощна. Тя има стойност true, ако a, b и c не са страни на триъгълник. Получена е след прилагане отрицание на условието a, b и c да са страни на триъгълник, т.е. на условието
a > 0 && b > 0 && c > 0 && a + b > c && a + c > b && b + c > a
като са използвани законите на де Морган.

Закони на де Морган:
!!A е еквивалентно на A
!(А || B) е еквивалентно на !A && !B
!(A && B) е еквивалентно на !A || !B

Задача 24. Да се напише програма, която на цялата променлива k присвоява номера на квадранта, в който се намира точка с координати (x, y). Точката не лежи на координатните оси, т.е. x.y ≠ 0.

Програмата Zad24.cpp решава задачата.
Program Zad24.cpp
#include <iostream.h>
int main()
{ cout << "x=";
double x;
cin >> x;
if (!cin)
{cout << "Error, Bad input! \n";
return 1;
}
cout << "y=";
double y;
cin >> y;
if (!cin)
{cout << "Error, Bad input! \n";
return 1;
}
if (x*y == 0)
{cout << "The input is incorrect! \n";
return 1;
}
int k;
if (x*y>0) {if (x>0) k = 1; else k= 3;}
else
if (x>0) k = 4; else k = 2;
cout << "The point is in: " << k << "\n";
return 0;
}

[ivakavlad]

4.4.3. Оператор switch

Често се налага да се избере за изпълнение един измежду множество от варианти. Пример за това дава следната задача.

Задача 25. Да се напише програма, която въвежда цифра, след което я извежда с думи.

За решаването на задачата трябва да се реализира следната неелементарна функция:



Последното може да стане чрез следната програма:
#include <iostream.h>
int main()
{cout << "i= ";
int i;
cin >> i;
if (!cin)
{cout << "Error, bad input!\n";
return 1;
}
if (i < 0 || i > 9)
{cout << "Bad input \n";
return 1;
}
else
if (i == 0) cout << "zero \n";
else if (i == 1) cout << "one \n";
else if (i == 2) cout << "two \n";
else if (i == 3) cout << "three \n";
else if (i == 4) cout << "four \n";
else if (i == 5) cout << "five \n";
else if (i == 6) cout << "six \n";
else if (i == 7) cout << "seven \n";
else if (i == cout << "eight \n";
else if (i == 9) cout << "nine \n";
return 0;
}
В нея са използвани вложени if и if/else оператори, условията на които сравняват променливата i с цифрите 0, 1, 2, …, 9.

Има по-удобна форма за реализиране на това влагане. Постига се чрез оператора за избор на вариант switch.
Програма Zad25.cpp е друго решение на задачата.
Program Zad25.cpp
#include <iostream.h>
int main()
{cout << "i= ";
int i;
cin >> i;
if (!cin)
{cout << "Error, bad input!\n";
return 1;
}
if (i < 0 || i > 9)
{cout << "Bad input \n";
return 1;
}
else
switch (i)
{case 0 : cout << "zero \n"; break;
case 1 : cout << "one \n"; break;
case 2 : cout << "two \n"; break;
case 3 : cout << "three \n"; break;
case 4 : cout << "four \n"; break;
case 5 : cout << "five \n"; break;
case 6 : cout << "six \n"; break;
case 7 : cout << "seven \n"; break;
case 8 : cout << "eight \n"; break;
case 9 : cout << "nine \n"; break;
}
return 0;
}
Операторът switch започва със запазената дума switch (ключ), следван от, ограден в кръгли скобки, цял израз. Между фигурните скобки са изброени вариантите на оператора. Описанието им започва със запазената дума case (случай, вариант), следвана в случая от цифра, наречена етикет, двоеточие и редица от оператори.
Изпълнение на програмата
След въвеждането на стойност на променливата i се извършва проверка за коректност на въведеното. Нека въведената стойност е 7. Изпълнението на оператора switch причинява да бъде пресметната стойността на израза i – в случая 7. След това последователно сравнява тази стойност със стойностите на етикетите до намиране на етикета 7 и изпълнява редицата от оператори след него. В резултат върху екрана се извежда
seven
курсурът се премества на нов ред и се прекъсва изпълнението на оператора switch. Последното е причинено от оператора break в края на редицата от оператори за варианта с етикет 7.

Операторът switch реализира избор на вариант от множество варианти (възможности). Синтаксисът и семантиката му са дадени на Фиг. 7.


Синтаксис
switch (<израз>)
{ case <израз1> : <редица_от_оператори1>
case <израз2> : <редица_от_оператори2>
…
case <изразn-1> : <редица_от_операториn-1>
[default : <редица_от_операториn>]
}
където
- switch (ключ), case (случай, избор или вариант) и default (по премълчаване) са запазени думи на езика;
- <израз> е израз от допустим тип (Типовете bool, int и char са допустими, реалните типове double и float не са допустими). Ще го наричаме още switch-израз.
- <израз1>, <израз2>, …, <изразn-1> са константни изрази, задължително с различни стойности.
- <редица_от_операториi> (i = 1, 2, …, n) се дефинира по следния начин:
<редица_от_оператори> ::= <празно>|
<оператор>|
<оператор><редица_от_операт� �ри>
Семантика
Намира се стойността на switch-израза. Получената константа се сравнява последователно със стойностите на етикетите <израз1>, <израз2>, … При съвпадение, се изпълняват операторите на съответния вариант и операторите на всички варианти, разположени след него, до срещане на оператор break. В противен случай, ако участва default-вариант, се изпълнява редицата от оператори, която му съответства и в случай, че не участва такъв – не следват никакви действия от оператора switch.


Фиг. 7.

Между фигурните скобки са изброени вариантите на оператора. Всеки вариант (без евентуално един) започва със запазената дума case, следвана от израз (нарича се още case–израз или етикет), който се пресмята по време на компилация. Такива изрази се наричат константни. Те не зависят от входните данни. След константния израз се поставя знакът двоеточие, следван от редица от оператори (оператори на варианта), която може да е празна. Сред вариантите може да има един (не е задължителен), който няма case-израз и започва със запазената дума default. Той се изпълнява в случай, че никой от останалите варианти не е бил изпълнен.
Съществува възможност програмистът да съобщи на компилатора, че желае да се изпълни само редицата от оператори на варианта с етикет, съвпадащ със стойността на switch-израза, а не и всички следващи го. Това се реализира чрез използване на оператор break в края на редицата от оператори на варианта. Този оператор предизвиква прекъсване на изпълнението на оператора switch и предаване на управлението на първия оператор след него (Фиг. 8.).
Операторът break принадлежи към групата на т. нар. оператори за преход. Тези оператори предават управлението безусловно в някаква точка на програмата.


Синтаксис
break;
Семантика
Прекратява изпълнеието на най-вътрешния съдържащ го оператор switch или оператор за цикъл. Изпълнението на програмата продължава от оператора, следващ (съдържащ) прекъснатия.


Фиг. 8.

Програмистът съзнателно пропуска оператора break, когато за няколко различни стойности от множеството от стойности, трябва да се извършат еднакви действия.
Забележка: Ако в оператора switch не е използван операторът break, ще бъдe изпълнена редицата от оператори на варианта, чийто case-израз съвпада със стойността на switch-израза и също всички след него.

Използването на оператора switch има едно единствено предимство пред операторите if и if/else – прави реализацията по-ясна. Основен негов недостатък е, че може да се прилага при много специални обстоятелства, произтичащи от наложените ограничения на типа на switch-израза, а именно, той трябва да е цял, булев или символен. Освен това, използването на оператора break, затруднява доказването на важни математически свойства на програмите, използващи break.

Задачи върху оператора switch

Задача 26. Да се напише програма, която по зададено реално число x намира стойността на един от следните изрази:
y = x - 5
y = sin(x)
y = cos(x)
y = exp(x).
Изборът на желания израз да става по следния начин: при въвеждане на цифрата 1 се избира първият, на 2 – вторият, на 3 – третият и на 4 – четвъртия израз.

Програма Zad25.cpp решава задачата.
#include <iostream.h>
#include <iomanip.h>
#include <math.h>
int main()
{cout << "=================================\n";
cout << "| y = x-5 -> 1 |\n";
cout << "| y = sin(x) -> 2 |\n ";
cout << "| y = cos(x) -> 3 |\n";
cout << "| y = exp(x) -> 4 |\n";
cout << "=================================\n";
cout << " 1, 2, 3 or 4? \n";
int i;
cin >> i;
if (!cin)
{cout << "Error, Bad input!!! \n";
return 1;
}
if (i == 1 || i == 2 || i == 3 || i == 4)
{cout << "x= ";
double x;
cin >> x;
if (!cin)
{cout << "Error, Bad input!! \n";
return 1;
}
double y;
switch (i)
{case 1: y = x - 5; break;
case 2: y = sin(x); break;
case 3: y = cos(x); break;
case 4: y = exp(x); break;
}
cout << "y= " << y << "\n";
}
else
{cout << "Error, Bad choise!!\n";
return 1;
}
return 0;
}


Задачи

Задача 1. Явява ли се условен оператор редицата от символи:
а) if (x < y) x = 0; else y = 0;
б) if (x > y) x = 0; else cin >> y;
в) if (x >= y) x = 0; y = 0; else cout << z;
г) if (x < y) ; else z = 5;
д) if (x < y < z) then z = z + 1;
е) if (x != y) z = z+1; x = x + y;
Задача 2. Кое условие е в сила след запазената дума else на условния оператор:
а) if (a > 1 && a < 5) b = 5; else b = 10;
б) if (a < 1 || a > 5) b = a; else a = b;
в) if (a = b || a = c || b = c) c = a + b; else c = a – b;
Задача 3. Да се намерят грешките в следните оператори:
а) if (1 < x < 2) x = x + 1; y = 0;
else x = 0; y = y + 1;
б) if (1 < x) && (x < 2)
{x = x + 1;
y = 0;
};
else
{x = 0;
y = y + 1;
};
Задача 4. Да се напише програма, която по дадено реално число x намира стойността на y, където

Задача 5. Да се напише програма, която по зададени стойности на реалните променливи a, b и c намира:
а) min{a+b+c, a.b.c} + 15.2
б) max{a2 - b3 + c, a – 17.3 b, 3.1 a + 3.5 b – 8 c} - 17.9.
Задача 6. Да се напише програма, която увеличава по-малкото от две дадени цели неравни числа пет пъти, а по-голямото число намалява 8 пъти.
Задача 7. Да се напише програма, която въвежда четири реални числа и ги извежда във възходящ (низходящ) ред върху екрана.
Задача 8. Дадени са три числа a, b и c. Да се напише програма, в резултат от изпълнението на която, ако е в сила релацията a ≥ b ≥ c, числата се удвояват, в противен случай числата се заменят с техните абсолютни стойности.
Задача 9. Да се намери стойността на z след изпълнението на операторите
z = 0;
if (x > 0) if (y > 0) z = 1; else z = 2;
ако:
а) x = y = 1 б) x = 1, y = -1 в) x = -1, y = 1

Задача 10. Да се запише указаното действие чрез един условен оператор:

б) d = max(a, b, c)

Задача 11. Да се напише условен оператор, който е еквивалентен на оператора за присвояване
x = a || b && c;
където всички променливи са булеви и в който не се използват логически операции (Например, операторът x = not a; е еквивалентен на оператора if (a) x = false; else x = true.
Задача 12. Да се напише оператор за присвояване, еквивалентен на условния оператор
if (a) x = b; else x = c;
(всички променливи са булеви).
Задача 13. Да се напише програма, която по зададено число a, намира корена на уравнението f(x) = 0, където

[ivakavlad]

Глава 4

4.5. Оператори за цикъл

Операторите за цикъл се използват за реализиране на циклични изчислителни процеси.
Изчислителен процес, при който оператор или група оператори се изпълняват многократно за различни стойности на техни параметри, се нарича цикличен.
Съществуват два вида циклични процеси:
индуктивни и
итеративни.
Цикличен изчислителен процес, при който броят на повторенията е известен предварително, се нарича индуктивен цикличен процес.

Пример: По дадени цяло число n и реално число x, да се намери сумата

Ако S има начална стойност 1, за да се намери сумата е необходимо n пъти да се повторят следните действия:

а) конструиране на събираемо

б) добавяне на събираемото към S.


Цикличен изчислителен процес, при който броят на повторенията не е известен предварително, се нарича итеративен цикличен процес. При тези циклични процеси, броят на повторенията зависи от някакво условие.
Пример: По дадени реални числа x и e > 0, да се намери сумата

където сумирането продължава до добавяне на събираемо, абсолютната стойност на което е по-малка от e.
Ако S има начална стойност 1, за да се намери сумата е необходимо да се повторят следните действия:

а) конструиране на събираемо

б) добавяне на събираемото към S
докато абсолютната стойност на последното добавено към сумата S събираемо стане по-малка от e.
В този случай, броят на повторенията зависи от стойностите на x и e.
В езика C++ има три оператора за цикъл:
оператор for
Чрез него могат да бъдат реализирани произволни циклични процеси, но се използва главно за реализиране на индуктивни циклични процеси.
оператори while и do/while
Използват се за реализиране на произволни циклични процеси – индуктивни и итеративни.

4.5.1. Оператор for

Използва се основно за реализиране на индуктивни изчислителни процеси. Чрез пример ще илюстрираме използването му.

Задача 26. Да се напише програма, която по зададено естествено число n, намира факториела му.

Тъй като n! = 1.2. … .(n-1).n, следната редица от оператори го реализира:
int fact = 1;
fact = fact * 1;
fact = fact * 2;
…
fact = fact * (n-1);
fact = fact * n;
В нея операторите за присвояване са написани по следния общ шаблон:
fact = fact * i;
където i е цяла променлива, получаваща последователно стойностите 1, 2, …, (n-1), n.
Следователно, за да се намери n! трябва да се реализира повтаряне изпълнението на оператора fact = fact * i, за i = 1, 2, …, n. Това може да стане с помощта на оператора for.

Програма Zad26.cpp решава задачата.
Program Zad26.cpp
#include <iostream.h>
int main()
{cout << "n= ";
int n;
cin >> n;
if (!cin)
{cout << "Error, Bad Input! \n";
return 1;
}
if (n <= 0)
{cout << "Incorrect Input! \n";
return 1;
}
int fact = 1;
for (int i = 1; i <= n; i++)
fact = fact * i;
cout << n << "! = " << fact << "\n";
return 0;
}
Операторът for е в одебелен шрифт. Той започва със запазената дума for (за). В кръгли скобки след нея е реализaцията на конструкцията i = 1, 2, …, n. Тя се състои от три части: инициализация (int i = 1, условие (i <= n) и корекция (i++), отделени с ;. Забележете, че операторът i++ не завършва с ;. След този фрагмент е записан операторът fact = fact * i;, описващ действията, които се повтарят. Нарича се тяло на цикъла.
Изпълнението на програмата започва с въвеждане стойност на променливата n и проверка валидността на въведеното. Нека n = 3. След дефиницията на цялата променлива fact, в ОП за нея са отделени 4 байта, инициализирани с 1. Изпълнението на оператора for предизвиква за цялата променлива i да бъдат заделени 4 байта, които да се инициализират също с 1. Следва проверка на условието i<=n и тъй като то е истина (1<=3), се изпълнява операторът fact = fact*i;, след което fact получава стойност 1. Изпълнението на оператора i++ увеличава текущата стойност на i с 1 и новата й стойност вече е 2. Отново следва проверка на условието i<=n и тъй като то е истина (2<=3), се изпълнява операторът fact = fact*i;, след което fact получава стойност 2. Изпълнението на оператора i++ увеличава текущата стойност на i с 1 и новата й стойност вече е 3. Пак следва проверка на условието i<=n и тъй като то отново е истина (3 <= 3), се изпълнява операторът fact = fact*i;, след което fact получава стойност 2*3, т.е. 6. Изпълнението на оператора i++ увеличава текущата стойност на i с 1 и новата й стойност вече е 4. Условието i<=n е лъжа и изпълнението на оператора for завършва.
Въпреки, че променливата i е дефинирана в оператора for, тя е “видима” (може да се използва) след изпълнението му, като стойността й е първата, за която стойността на условието i<=n не е в сила (в случая 4).
На Фиг. 9 е дадено детайлно описание на оператора for.

Синтаксис
for (<инициализация>; <условие>; <корекция>)
<оператор>
където
- for (за) е запазена дума.
- <инициализация> е или точно една дефиниция с инициализация на една или повече променливи, или няколко оператора за присвояване или въвеждане, отделени със , и не завършващи с ;.
- <условие> е булев израз.
- <корекция> е един или няколко оператора, незавършващи с ;. В случай, че са няколко, отделят се със ,.
- <оператор> е точно един произволен оператор. Нарича се тяло на цикъла.
Семантика
Изпълнението започва с изпълнение на частта <инициализация>. След това се намира стойността на <условие>. Ако в резултат се е получило false, изпълнението на оператора for завършва, без тялото да се е изпълнило нито веднъж. В противен случай последователно се повтарят следните действия:
- Изпълнение на тялото на цикъла;
- Изпълнение на операторите от частта <корекция>;
- Пресмятане стойността на <условие>
докато стойността на <условие> е true.
Следната схема илюстрира изпълнението му:

false

true
for (<инициализация>; <условие>; <корекция>)

<оператор>

…

Фиг. 9.

Възможно е частите <инициализция>, <условие> и <корекция> поотделно или заедно, да са празни. Разделителите ( между тях обаче трябва да фигурират. Ако частта <условие> е празна, подразбира се true.

Забележки:
1. Тялото на оператора for е точно един оператор. Ако повече оператори трябва да се използват, се оформя блок.
2. Частта <инициализация> се изпълнява само веднъж – в началото на цикъла. Възможно е да се изнесе пред оператора for и остане празна (Пример 1). В нея не са допустими редици от оператори и дефиниция на променливи, т.е. недопустими са:
for (int i, i = 4; …
или
int i;
for (i = 4, int j = 5; …
а също две дефиниции, например
for(int i=3, double a = 3.5; …
Нарича се така, тъй като в нея обикновено се инициализират една или повече променливи.
3. Частта <корекция> се нарича така, тъй като обикновено чрез нея се модифицират стойностите на променливите, инициализирани в частта <инициализация>. Тя може да се премести в тялото на оператора for като се оформи блок от вида {<оператор> <корекция>;} (Пример 2).
4. Ако частта <условие> е празна, подразбира се true. За да се избегне зацикляне, от тялото на цикъла при определени условия трябва да се излезе принудително, например чрез оператора break (Пример 3). Това обаче е лош стил на програмиране и ние не го препоръчваме.
5. Следствие разширената интерпретация на true и false, частта <условие> може да бъде и аритметичен израз. Това също е лош стил на програмиране и не го препоръчваме.

Примери:
1. int i = 1;
for (; i<= n; i++)
fact = fact* i;
2. for (int i = 1; i<= n
{fact = fact* i;
i++;
}
3. for (int i = 1; ; i++)
if (i > n) break;
else fact = fact* i;

Област на променливите, дефинирани в заглавната част на for

Под област на променлива се разбира мястото в програмата, където променливата може да се използва. Казва се още където тя е “видима”.
Съгласно стандарта ANSI, областта на променлива, дефинирана в заглавната част на цикъла for започва от дефиницията й и продължава до края на цикъла.
Това значи, че тези променливи не са видими след оператора for, в който са дефинирани, т.е. фрагментът
for (int i = 1; i <= n; i++)
{…
}
for (i = 1; i <= m; i++)
{…
}
е недопустим - ще предизвика синтактична грешка заради недефинирана променлива i в заглавната част на втория оператор for.
Но тъй като това е ново решение на специалистите, поддържащи езика, повечето реализации в т.число и реализацията на Visual C++ 6.0, използват стария вариант, според който областта на променлива, дефинирана в заглавната част на цикъла for започва от дефиницията й и продължава до края на блока, в който се намира оператора for. Така, за реализацията на Visual C++ 6.0, горният фрагмент е напълно допустим. А фрагментът
for (int i = 1; i <= n; i++)
{…
}
for (int i = 1; i <= m; i++)
{…
}
сигнализира повторна дефиниция на променливата i.


Задачи върху оператора for

Задача 27. За какво може да бъде използвана следната програма?

Program Zad27.cpp
#include <iostream.h>
int main()
{cout << "n= ";
int n;
cin >> n;
if (!cin)
{cout << "Error, Bad input! \n";
return 1;
}
if (n <= 0)
{cout << "Incorrect input! \n";
return 1;
}
int f = 1;
for (int i = 1; i <= n; cin >> i)
f = f * i;
cout << f << "\n";
return 0;
}
Забележете, че тази програма илюстрира използването на оператора for за реализиране на итеративни циклични процеси. Това обаче се счита за лош стил за програмиране.

Препоръка: Използвайте оператора for само за реализиране на индуктивни циклични процеси. Освен това, ако for има вида:
for(i = start; i < (или i <= ) end; i = i + increment)
{ …
}
не променяйте i, start, end и increment в тялото на цикъла. Това е лош стил за програмиране. Ако цикличният процес, който трябва да реализирате, не се вмества в тази схема, не използвайте оператора for.


Задача 28. Да се напише програма, която по зададени x – реално и n – естествено число, пресмята сумата

Програма Zad28.cpp решава задачата.
Program Zad28.cpp
#include <iostream.h>
int main()
{cout << "x= ";
double x;
cin >> x;
if (!cin)
{cout << "Error, Bad input! \n";
return 1;
}
cout << "n= ";
short n;
cin >> n;
if (!cin)
{cout << "Error, Bad input! \n";
return 1;
}
if (n <= 0)
{cout << "Incorrect input! \n";
return 1;
}
double x1 = 1;
double s = 1;
for (int i = 1; i <= n; i++)
{x1 = x1 * x/i;
s = s + x1;
}
cout << "s= " << s << "\n";
return 0;
}


Задача 29. Нека n и m са дадени естествени числа, n ≥ 1, m > 1. Да се напише програма,която определя броя на елементите от серията числа

които са кратни на m.

Програма Zad29.cpp решава задачата.
Program Zad29.cpp
#include <iostream.h>
int main()
{cout << "n= ";
int n;
cin >> n;
if (!cin)
{cout << "Error, Bad input! \n";
return 1;
}
if (n < 1)
{cout << "Incorrect input! \n";
return 1;
}
cout << "m= ";
int m;
cin >> m;
if (!cin)
{cout << "Error, Bad input! \n";
return 1;
}
if (m <= 1)
{cout << "Incorrect input! \n";
return 1;
}
int br = 0;
for (int i = 1; i <= n; i++)
if ((i*i*i + 7*i*i + n*n*n) % 7 == 0) br++;
cout << "br= " << br << "\n";
return 0;
}

Задача 30. Дадено е естественото число n, n ≥ 1. Да се напише

програма, която намира най-голямото число от серията числа:

Програма Zad30.cpp решава задачата.
Program Zad30.cpp
#include <iostream.h>
#include <math.h>
int main()
{cout << "n= ";
int n;
cin >> n;
if (!cin)
{cout << "Error, Bad input! \n";
return 1;
}
if (n < 1)
{cout << "Incorrect input! \n";
return 1;
}
double max = cos(n+1/n);
for (int i = 2; i <= n; i++)
{double p = i*i*cos(n+i/n);
if (p > max) max = p;
}
cout << "max= " << max << "\n";
return 0;
}

Задача 31. Да се напише програма, която извежда върху екрана таблицата от стойностите на функциите sin x и cos x в интервала [0, 1].
Програма Zad31.cpp решава задачата.
Program Zad31.cpp
#include <iostream.h>
#include <iomanip.h>
#include <math.h>
int main()
{cout << setprecision(5) << setiosflags(ios :: fixed);
for (double x = 0; x <= 1; x = x + 0.1)
cout << setw(10) << x << setw(10) << sin(x)
<< setw(10) << cos(x) << "\n";
return 0;
}

[ivakavlad]

4.5.2. Оператор while

Чрез този оператор може да се реализира произволен цикличен процес. С пример ще илюстрираме използването му.


Задача 32. Да се напише програма, която по дадени реални числа x и e (e > 0), прилижено пресмята сумата

Сумирането да продължи докато абсолютната стойност на последното добавено събираемо стане по-малка от e.

В тази задача броят на повторенията предварително не е известен, а зависи от условието |x1|< e, където с x1 е означено произволно събираемо. За решаването й е необходимо да се премине през следните стъпки:
Въвеждане на стойности на x и e.
Инициализация x1 = 1; s = 1.
Докато е в сила условието |x1|

[ivakavlad]

4.5.3. Оператор do/while

Използва се за реализиране на произволни циклични процеси. Ще го илюстрираме чрез пример, след което ще опишем неговите синтаксис и семантика. За целта ще използваме задача 37.

Програма Zad37_1.cpp реализира тази задача, като използва оператора do/while.
Program Zad37_1.cpp
#include <iostream.h>
#include <iomanip.h>
#include <math.h>
int main()
{cout << "x= ";
double x;
cin >> x;
if (!cin)
{cout << "Error, Bad input! \n";
return 1;
}
if (x < -1 || x > 1)
{cout << "Incorrect Input! \n";
return 1;
}
cout << "eps= ";
double eps;
cin >> eps;
if (!cin)
{cout << "Error, Bad input! \n";
return 1;
}
if (eps <= 0)
{cout << "Incorrect input! \n";
return 1;
}
double x1;
double x2 = x;
double s = x;
int i = 2;
do
{x1 = x2;
x2 = -x1 * x * x / (i*(i+1));
s = s + x2;
i = i + 2;
} while (fabs(x1-x2) >= eps);
cout << setprecision(5) << setiosflags(ios :: fixed);
cout << "s=" << setw(10) << s << "\n";
return 0;
}
Операторът do/while в нея е в одебелен шрифт. Започва със запазената дума do (прави, повтаряй следното), следва оператор (в случая блок), който определя действията, които се повтарят и затова се нарича тяло на цикъла. Запазената дума while (докато) отделя тялото на оператора от булевия израз fabs(x1-x2) >= eps. Последният е ограден в кръгли скобки и определя условието за завършване изпълнението на цикъла.
Ще проследим изпълнението на програмата за x = 1 и eps = 0.5.
След изпълнението на операторите за въвеждане и дефинициите на s, x1, x2 и i, състоянието на паметта е следното:
x eps x1 x2 s i
1.0 0.5 - 1.0 1.0 2
Изпълнението на оператора за цикъл започва с изпълнение на тялото на цикъла – блока
{x1 = x2;
x2 = -x1 * x * x / (i*(i+1));
s = s + x2;
i = i + 2;
}
след което се получава:
x eps x1 x2 s i
1.0 0.5 1.0 -0.16667 0.83333 4
Пресмята се стойността на булевия израз fabs(x1-x2) >= eps и тъй като тя е true, повторно се изпълняват операторите от блока, съставящ тялото. В резултат имаме:
x eps x1 x2 s i
1.0 0.5 -0.16667 0.00833 0.84167 6
Сега вече стойността на булевия израз, определящ условието за завършване, има стойност false. Изпълнението на оператора за цикъл завършва. С извеждането на стойността на сумата s завършва и изпълнението на програмата.
Забелязваме, че в тази програма, настройката на променливите x1 и x2 става в тялото на цикъла do/while, а не извън него. Това се обуславя от факта, че тялото на този вид цикъл поне веднъж ще се изпълни.
Описанието на синтаксиса и семантиката на оператора do/while е илюстрирано на Фиг. 11.


Синтаксис
do
<оператор>
while (<условие>);
където
- do (прави, повтаряй докато …) и while (докато) са запазени думи на езика.
- <оператор> е точно един оператор. Той описва действията, които се повтарят и се нарича тяло на цикъла.
- <условие> е булев израз. Нарича се условие за завършване на цикъла. Огражда се в кръгли скобки.
Семантика
Изпълнява се тялото на цикъла, след което се пресмята стойността на <условие>. Ако то е false, изпълнението на оператора do/while завършва. В противен случай се повтарят действията: изпълнение на тялото и пресмятане стойността на <условие>, докато стойността на <условие> е true. Веднага, след като стойността му стане false, изпълнението на оператора завършва.


Фиг. 11.
Забележки:
1. Между запазените думи do и while стои точно един оператор. Ако няколко действия трябва да се извършат, оформя се блок.
2. Дефинициите в тялото, не са видими в <условие>. Например, не е допустим фрагментът:
double x2 = x;
double s = x;
int i = 2;
do
{double x1 = x2;
x2 = -x1 * x * x / (i*(i+1));
s = s + x2;
i = i + 2;
} while (fabs(x1-x2) >= eps);
Компилаторът ще съобщи, че x1 не е дефиниран на линия:
} while (fabs(x1-x2) >= eps);
Следователно, всички променливи в <условие> трябва да са дефинирани извън оператора do/while.
3. Следствие разширената интерпретация на true и false, частта <условие> може да е аритметичен израз. Това е лош стил за програмиране и ние не го препоръчваме.
4. Операторът do/while завършва с ;.

Задачи върху оператора do/while

Задача 38. Да се напише програма, която намира произведението на целите числа от m до n, където m и n са дадени естествени числа и m ≤ n. За целта да се използва операторът do/while.

Програма Zad38.cpp решава задачата.
Program Zad38.cpp
#include <iostream.h>
int main()
{cout << "m= ";
int m;
cin >> m;
if (!cin)
{cout << "Error, Bad Input! \n";
return 1;
}
if (m <= 0)
{cout << "Incorrect Input! \n";
return 1;
}
cout << "n= ";
int n;
cin >> n;
if (!cin)
{cout << "Error, Bad Input! \n";
return 1;
}
if (n <= 0)
{cout << "Incorrect Input! \n";
return 1;
}
if (m > n)
{cout << "Incorrect Input! \n";
return 1;
}
int prod = 1;
int i = m;
do
{prod = prod * i;
i++;
} while (i <= n);
cout << prod << "\n";
return 0;
}
Тъй като е в сила релацията m ≤ n, произведението ще съдържа поне един елемент от редицата от цели числа {m, m+1, m+2, …, n}. Това прави възможно използването на оператора do/while.

Задача 39. Да се напише програма, в резултат от изпълнението на която се изяснява, има ли сред числата от серията: i3 – 3.i + n3, i = 1, 2, …, n, число, кратно на 5. Ако има, да се изведе true, иначе – false.

Решението на тази задача изисква последователно да се конструират елементите от серията числа. Това продължава до намиране на първото число, кратно на 5, или до изчерпване на редицата без число с това свойство да е намерено.

Програма Zad39_1.cpp е едно решение на задачата.
Program Zad39_1.cpp
#include <iostream.h>
int main()
{cout << "n= ";
int n;
cin >> n;
if (!cin)
{cout << "Error, Bad Input!!! \n";
return 1;
}
if (n <= 0 )
{cout << "Incorrect Input! \n";
return 1;
}
int i = 0;
int a;
do
{i++;
a = i*i*i - 3*i + n*n*n;
} while (a%5 != 0 && i < n);
if (a%5 == 0) cout << "true\n";
else cout << "false\n";
return 0;
}

Възникват два въпроса:
1) Ако условието условие (a%5 != 0 && i < n) стане лъжа, тъй като се излиза от цикъла, правилно ли следващият оператор определя резултата?
От законите на де Морган следва, че е истина a%5 == 0 || i = n. Ако a%5 == 0, тъй като a е i-тият елемент на серията и i ≤ n, наистина в серията съществува елемент с исканото свойство. Ако a%5 не е 0, следва че i = n ще е в сила, т.е. a е n – тият елемент и за него свойството не е в сила. Но тъй като са сканирани всички елементи от серията, наистина в нея не съществува елемент с търсеното свойство.
2) Ще се стигне ли до състояние, при което горното условие наистина ще е лъжа?
Условието (a%5 != 0 && i < n) ще е лъжа, ако a%5 == 0 || i = n е в сила и се достига или когато в серията има елемент с търсеното свойство, или е сканирана цялата серия и i указва последния й елемент. Ако в серията няма елемент с исканото свойство, тъй като i е инициализирано с 0 и се увеличава с 1 на всяка стъпка от изпълнението на програмата, в един момент ще стане вярно условието i = n, т.е. цикълът ще завърши изпълнението си.

Друго решение дава програмата Zad39_2.cpp. То не съдържа фрагментът, въвеждащ стойност на променливата n.

Program Zad39_2.cpp
#include <iostream.h>
int main()
{ …
int i = 1;
int a;
do
{a = i*i*i - 3*i + n*n*n;
i++;
} while (a%5 != 0 && i <= n);
if (a%5 == 0) cout << "true\n";
else cout << "false\n";
return 0;
}
Лошото при това решение, че в тялото на цикъла има разминаване на елемента от серията, запомнен в a, и поредния му номер.

Задача 40. Да се напише програма, която въвежда естествено число и установява, дали цифрата 5 участва в записа на числото.

Програма Zad40.cpp решава задачата.
Program Zad40.cpp
#include <iostream.h>
int main()
{cout << "n= ";
int n;
cin >> n;
if (!cin)
{cout << "Error, Bad Input!!! \n";
return 1;
}
if (n <= 0 )
{cout << "Incorrect Input! \n";
return 1;
}
int d;
do
{d = n % 10;
n = n / 10;
} while (d != 5n && n != 0);
if (d == 5) cout << "true\n";
else cout << "false\n";
return 0;
}
В тялото на цикъла последователно се намират цифрата на единиците на числото n и числото без цифрата на единиците си. Това продължава докато поредната цифра е различна от 5 и останалото число е различно от 0.

Задача 41. Нека a е неотрицателно реално число. Да се напише програма, която приближено пресмята квадратен корен от a по метода на Нютон.
Упътване: (метод на Нютон) Дефинира се редица от реални числа x0, x1, x2, x3, … по следния начин:


Сумирането да продължи докато абсолютната стойност на разликата на последните два констуирани елемента на редицата е по-малка от e, e>0 е дадено достатъчно малко реално число.

Програма Zad41.cpp решава задачата.
Program Zad41.cpp
#include <iostream.h>
#include <iomanip.h>
#include <math.h>
int main()
{cout << "a= ";
double a;
cin >> a;
if (!cin)
{cout << "Bad Input! \n";
return 1;
}
if (a < 0)
{cout << "Incorrect Input! \n";
return 1;
}
cout << "eps= ";
double eps;
cin >> eps;
if (!cin)
{cout << "Bad Input! \n";
return 1;
}
if (eps <= 0 || eps > 0.5)
{cout << "Incorrect Input! \n";
return 1;
}
double x0;
double x1 = 1;
do
{x0 = x1;
x1 = 0.5*(x0 + a / x0);
} while (fabs (x1-x0) >= eps);
cout << setprecision(6) << setiosflags(ios :: fixed);
cout << "sqrt(" << a << ")= " << setw(10) << x1 << "\n";
return 0;
}

[ivakavlad]

4.5.4. Вложени оператори за цикъл

Тялото на кой де е от операторите за цикъл е произволен оператор. Възможно е да е оператор за цикъл или блок, съдържащ оператор за цикъл. В тези случаи се говори за вложени оператори за цикъл.
Пример: Програмният фрагмент
for (int i = 1; i <= 3; i++)
for (int j = 1; j <= 5; j++)
cout << “(“ << i << “, “ << j << “)\n”;
съдържа вложен оператор for и се изпълнява по следния начин: Променливата i получава последователно целите стойности 1, 2 и 3. За всяка от тези стойности, променливата j получава стойностите 1, 2, 3, 4 и 5 и за тях се изпълнява операторът
cout << “(“ << i << “, “ << j << “)\n”;
В резултат се конструират и извеждат на отделни редове всички двойки от вида (i, j), където i = 1, 2, 3 и j = 1, 2, 3, 4, 5.

При влагането на цикли, а също при използването на блокове, възникват проблеми, свързани с видимостта на дефинираните променливи.

Област на променлива

Общото правило за дефиниране на променлива е, дефиницията й да е възможно най-близко до мястото където променливата ще се използва най-напред.
Областта на една променлива започва от нейната дефиниция и продължава до края на блока, в който променливата е дефинирана. На Фиг. 12 за променливите a, b и c са определени областите им.

int main()
{…
double a;
…
for ( … )
{…
double b; област на a
…
for ( … ) област на b
{ …
int c;
… област на c
}
}
return 0;
}

Фиг. 12

Променлива, дефинирана в някакъв блок, се нарича локална променлива за блока.
Променлива, дефинирана извън даден блок, но така, че областта й включва блока, се нарича нелокална променлива за този блок.
Всяка променлива е видима – може да се използва в областта си. Така b и c не могат да се използват навсякъде в тялото на main, а само с означените области.

Възниква въпросът: Може ли променливи с еднакви имена да бъдат дефинирани в различни блокове на програма?
Ако областите на променливите не се припокриват, очевидно няма проблем. Ако обаче те са вложени една в друга, пак е възможно, но е реализирано следното правило: локалната променлива “скрива” нелокалната в областта си.
Пример:
int main()
{…
double i;
…
for ( … )
{… област на
int i; double i
… област на int i;
}
…
}
Според правилото, в тялото на оператора for е видима цялата променлива i (локална за тялото), а не нелокалната double i.
Ако това води до конфликт с желанията ви, преименувайте например локалната за тялото на for променлива int i.

Задачи върху вложени оператори за цикъл

Задача 42. Да се напише програма, която намира всички решения на деофантовото уравнение a1.x1 + a2.x2 + a3.x3 + a4.x4 = a, където a1, a2, a3, a4 и a са дадени цели числа, а неизвестните x1, x2, x3 и x4 приемат стойности от интервала [p, q] / p и q са дадени цели числа, p<q /.

Програма Zad42.cpp решава задачата.
Program Zad42.cpp
#include <iostream.h>
#include <iomanip.h>
int main()
{cout << "a1= ";
int a1;
cin >> a1;
if (!cin)
{cout << "Error, Bad Input!\n";
return 1;
}
cout << "a2= ";
int a2;
cin >> a2;
if (!cin)
{cout << "Error, Bad Input!\n";
return 1;
}
cout << "a3= ";
int a3;
cin >> a3;
if (!cin)
{cout << "Error, Bad Input! \n";
return 1;
}
cout << "a4= ";
int a4;
cin >> a4;
if (!cin)
{cout << "Error, Bad Input!\n";
return 1;
}
cout << "a= ";
int a;
cin >> a;
if (!cin)
{cout << "Error, Bad Input!\n";
return 1;
}
cout << "p= ";
int p;
cin >> p;
if (!cin)
{cout << "Error, Bad Input!\n";
return 1;
}
cout << "q= ";
int q;
cin >> q;
if (!cin)
{cout << "Error, Bad Input!\n";
return 1;
}
if (p>=q)
{cout << "Error!\n";
return 1;
}
for (int x1 = p; x1<= q; x1++)
for (int x2 = p; x2 <= q; x2++)
for (int x3 = p; x3 <= q; x3++)
for (int x4 = p; x4 <= q; x4++)
if (a1*x1 + a2*x2 + a3*x3 + a4*x4 == a)
cout << setw(5) << x1 << setw(5) << x2
<< setw(5) << x3 << setw(5) << x4 << "\n";
return 0;
}

Задача 43. Да се напише програма, която проверява дали съществува решение на деофантовото уравнение a1.x1 + a2.x2 + a3.x3 + a4.x4 = a в интервала [p, q], където a1, a2, a3, a4, a, p и q са дадени цели числа, p<q.

Програма Zad43.cpp решава задачата. Ще пропуснем дефинициите на променливите a1, a2, a3, a4, a, p и q. Те са аналогични на тези от задача 42. Условието p < q прави подходящ оператора do/while.
Program Zad43.cpp
#include <iostream.h>
int main()
{…
if (p>=q)
{cout << "Error!!\n";
return 1;
}
int x1 = p;
bool b;
do
{int x2 = p;
do
{int x3 = p;
do
{int x4 = p;
do
{b = a1*x1 + a2*x2 + a3*x3 + a4*x4 == a;
x4++;
} while (!b && x4 <= q);
x3++;
} while (!b && x3 <= q);
x2++;
} while (!b && x2 <= q);
x1++;
} while (!b && x1 <= q);
if (b) cout << "yes\n";
else cout << "no\n";
return 0;
}


Задачи

Задача 1. Да се напише програма, която по дадено реално число x намира стойността на y:
а) y = ( ...((( x + 2) x + 3) x + 4) x +... + 10) x + 11
б) y= ( ...(((11x + 10)x + 9)x + x + ... + 2)x +1.
Задача 2. Да се напише програма, която намира сумата от кубовете на всички цели числа, намиращи се в интервала (x + lnx, x2 + 2x + ex), където x > 1.
Задача 3. Дадено е естественото число n (n ≥ 1). Да се напише програма, която намира броя на тези елементи от серията числа i3 - 7.i.n + n3 , i = 1, 2, ..., n, които са кратни на 3 или на 7.
Задача 4. Да се напише програма, която по дадено реално число x, намира стойността на сумата
а) y = sinx + sinx2 + sinx3 + ... + sinxn;
б) y = sinx + sin2x + sin3x + ... + sinnx;
в) y = sinx + sinsinx + sinsinsinx + ... + sinsin ...sinx

n пъти

Задача 5. Да се напише програма, която намира

Задача 6. Да се напише програма, която по дадено естествено число n ( n >= 1 ) намира стойността на f:
а) f = (2n)!! = 2.4.6. ... .2n;
б) f = (2n-1)!! = 1.3.5. ... .(2n-1);
в) f = n!!.


Задача 7. Дадено е естественото число n (n ≥ 1). Да се напише програма, която пресмята сумата:



(Да не се използват функциите exp и lоg).
Задача 8. Да се напише програма, която извежда в нарастващ ред всички трицифрени естествени числа, които не съдържат еднакви цифри (/ и % да не се използват).
Задача 9. Да се напише програма, която намира и извежда броя на точките с цели координати, попадащи в кръга с радиус R (R > 0) и център - координатното начало.
Задача 10. Да се напише програма, която извежда таблицата на истинност за булевата функция f = (a and b) or not (b or c) в следния вид
a b c f
------------------------------------
true true true true
true true false true
. . .
false false false true

Задача 11. Да се напише програма, която извежда върху екрана следната таблица:
1
1 2
1 2 3
1 2 3 4
1 2 3 4 5
1 2 3 4 5 6
1 2 3 4 5 6 7

Задача 12. Дадено е естествено число n (n ≥ 1). Да се напише програма, която намира и извежда първите n елемента от серията числа

(Да не се използват функциите exp и log).
Задача 13. Едно естествено число е съвършено, ако е равно на сумата от своите делители (без самото число). Например, 6 е съвършено, защото 6 = 1+2+3. Да се напише програма, която намира всички съвършени числа ненадминаващи дадено естествено число n.
Задача 14. Да се напише програма, която намира всички трицифрени числа от интервала [m, n], на които като се задраска цифрата на десетиците, намаляват цяло число пъти (m и n са дадени естествени числа, m < n).
Задача 15. Да се напише програма, която намира всички четирицифрени числа от интервала [m, n], на които като се задраска цифрата на стотиците, се делят на 11 (m и n са дадени естествени числа, m < n).
Задача 16. Да се напише програма, която намира всички четирицифрени числа от интервала [m, n], в записа на които участва цифрата 5 (m и n са дадени естествени числа, m < n).
Задача 17. Да се напише програма, която намира всички четирицифрени числа от интервала [m, n], цифрите на които образуват намаляваща редица (m и n са дадени естествени числа, m < n).
Задача 18. Да се напише програма, която намира всички петцифрени числа от интервала [m, n], цифрите на които са различни (m и n са дадени естествени числа, m < n).
Задача 19. Дадено е естествено число n (n > 1). Да се напише програма, която намира всички прости числа от интервала [2, n].
Задача 20. Да се напише програма, която намира всички прости делители на дадено естествено число n.

Задача 21. Да се напише програма, която по дадени реални числа x, a и e,e>0, приближено пресмята сумата.

Събирането да продължи докато бъде добавено събираемо, абсолютната стойност на което е по-малка от e (e > 0 е дадено реално достатъчно малко число).
Задача 22. Да се напише програма, която намира броя на цифрите в десетичния запис на дадено естествено число.
Задача 23. Да се напише програма, която проверява дали дадено естествено число е щастливо, т.е. едно и също е при четене отляво надясно и отдясно наляво.
Задача 24. Да се напише програма, която проверява дали сумата от цифрите на дадено естествено число е кратна на 3.
Задача 25. Да се напише програма, която намира всички естествени числа, ненадминаващи дадено естествено число n, които при преместване на първата им цифра най-отзад, се увеличават k пъти (k е дадено естествено число, k > 1).
Задача 26. Да се напише програма, която намира всички естествени числа от интервала [m, n], на които като се задраска k – тата цифра (отляво надясно), намаляват цяло число пъти (m, n и k са дадени естествени числа, m < n).
Задача 27. Да се напише програма, която намира всички естествени числа от интервала [m, n], на които като се задраска k – тата цифра (надясно наляво), намаляват цяло число пъти (m, n и k са дадени естествени числа, m < n).
Задача 28. За дадено естествено число да се провери дали цифрите му, гледани отляво надясно, образуват монотонно растяща редица.
Задача 29. За дадено естествено число да се провери дали цифрите му са различни.
Задача 30. Да се намерят всички прости делители на дадено естествено число.
Задача 31. Числата на Фибоначи се дефинират по следния начин:



Да се напише програма, която намира сумата на числата на Фибоначи от интервала [a, b] (a и b са дадени естествени числа).
Задача 32. За естествените числа n и m операцията ++ се определя по следния начин: n oo m = n + m + n%m. Да се напише програма, която намира всички двойки (n, m) от естествени числа, за които е в сила
n oo m = m oo n (m и n са естествени числа от интервала [a, b]).
Задача 33. За естествените числа n и m операцията ++ се определя по следния начин: n oo m = n + m + n%m. Да се напише програма, която проверява дали съществува двойкА (n, m) от естествени числа, за която е в сила релацията n oo m = m oo n (m и n са естествени числа от интервала [a, b]).


Допълнителна литература

К. Хорстман, Принципи на програмирането със C++, С., СОФТЕХ, 2000.
Ст. Липман, Езикът C++ в примери, “КОЛХИДА ТРЕЙД” КООП, С. 1993.
B. Stroustrup, C++ Programming Language. Third Edition,Addison – Wesley, 1997.

[ivakavlad]

Глава 5

Съставни типове данни.
Тип масив


Структура от данни масив

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

Логическо описание

Масивът е крайна редица от фиксиран брой елементи от един и същ тип. Към всеки елемент от редицата е възможен пряк достъп, който се осъществява чрез индекс. Операциите включване и изключване на елемент в/от масива са недопустими, т.е. масивът е статична структура от данни.

Физическо представяне

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

В езика C++ структурата масив се реализира чрез типа масив.

[ivakavlad]

Тип масив

В C++ структурата от данни масив е реализирана малко ограничено. Разглежда се като крайна редица от елементи от един и същ тип с пряк достъп до всеки елемент, осъществяващ чрез индекс с цели стойности, започващи от 0 и нарастващи с 1 до указана горна граница.

Задаване на масив

Типът масив се определя чрез задаване на типа и броя на елементите на редицата, определяща масив. Нека T е име или дефиниция на произволен тип, различен от псевдоним, void и функционален. За типа T и константния израз от интегрален или изброен тип с положителна стойност size, T[size] е тип масив от size елемента от тип T. Елементите се индексират от 0 до size–1. T се нарича базов тип за типа масив, а size – горна граница.
Примери:
int[5] е масив от 5 елемента от тип int, индексирани от 0 до 4;
double[10] е масив от 10 елемента от тип double, индексирани от 0 до 9;
bool[4] е масив от 4 елемента от тип bool, индексирани от 0 до 3.

Множество от стойности

Множеството от стойности на типа T[size] се състои от всички редици от по size елемента, които са произволни константи от тип T. Достъпът до елементите на редиците е пряк и се осъществява с помощта на индекс, като достъпът до първия елемент се осъществява с индекс със стойност 0, до последния – с индекс със стойност size-1, а до всеки от останалите елементи – с индекс със стойност с 1 по-голяма от тази на индекса на предишния елемент.
Примери:
1. Множеството от стойности на типа int[5] се състои от всички редици от по 5 цели числа. Достъпът до елементите на редиците се осъществява с индекс със стойности 0, 1, 2, 3 и 4.

int[5]




0 1 2 3 4

2. Множеството от стойности на типа double[10] се състои от всички редици от по 10 реални числа. Достъпът до елементите на редиците се осъществява с индекс със стойности 0, 1, 2, 3 и т.н. 9.

double[10]




0 1 9
Елементите от множеството от стойности на даден тип масив са константите на този тип масив.
Примери:
1. Следните редици {1,2,3,4,5}, {-3, 0, 1, 2, 0}, {12, -14, 8, 23, 1000} са константи от тип int[5].

2. Редиците {1.5, -2.3, 3.4, 4.9, 5.0, -11.6, -123, 13.7, -32.12, 0.98}, {-13, 0.5, 11.9, 21.98, 0.03, 1e2, -134.9, 0.09, 12.3, 15.6} са константи от тип double[10].

Променлива величина, множеството от допустимите стойности на която съвпада с множеството от стойности на даден тип масив, се нарича променлива от дадения тип масив. Понякога ще я наричаме само масив.
Фиг. 1 определя дефиницията на променлива от тип масив. Тук общоприетият запис е нарушен. Променливата се записва между името на типа и размерността.


<дефиниция_на_променлива_от _тип_масив> ::=
T <променлива>[size]; |
T <променлива>[size] = {<редица_от_константни_изра� �и>};
където
Т e име или дефиниция на произволен тип, различен от псевдоним, void, функционален;
<променлива> ::= <идентификатор>
size е константен израз от интегрален или изброен тип със положителна стойност;
<редица_от_константни_израз и> ::= <константен_израз>|
<константен_израз>, <редица_от_константни_израз и>
като константните изрази са от тип T или от тип, съвместим с него.


Фиг. 1.

Примери:
int a[5];
double c[10];
bool b[3];
enum {FALSE, TRUE} x[20];
double p[4] = {1.25, 2.5, 9.25, 4.12};

Вторият случай от дефиницията от Фиг. 1 се нарича дефиниция на масив с инициализация. При нея е възможно size да се пропусне. Тогава за стойност на size се подразбира броят на константните изрази, изброени при инициализацията. Ако size е указано и изброените константни изрази в инициализацията са по-малко от size, останалите се инициализират с 0.

Примери:
Дефиницията
int q[5] = {1, 2, 3};
е еквивалентна на
int q[] = {1, 2, 3, 0, 0};
Дефиницията
double r[] = {0, 1, 2, 3};
e еквивалентна на
double r[4] = {0, 1, 2, 3};
Забележка: Не са възможни конструкции от вида:
int q[5];
q = {0, 1, 2, 3, 4};
а също
int q[];
и
double r[4] = {0.5, 1.2, 2.4, 1.2, 3.4};
Фрагментите
<променлива>[size] и
<променлива>[size] = {<редица_от_константни_изра� �и>}
от дефиницията от Фиг. 1. могат да се повтарят. За разделител се използва знакът запетая.
Пример: Дефиницията
double m1[20], m2[35], proben[30];
е еквивалентна на дефинициите
double m1[20];
double m2[35];
double proben[30];

Инициализацията е един начин за свързване на променлива от тип масив с конкретна константа от множеството от стойности на този тип масив. Друг начин предоставят т.нар. индексирани променливи. С всяка променлива от тип масив е свързан набор от индексирани променливи. Фиг. 2. илюстрира техния синтаксис.


<индексирана_променлива> ::=
<променлива_от_тип_масив>[<индекс>]
където
<индекс> e израз от интегрален или изброен тип.
Всяка индексирана променлива е от базовия тип.


Фиг. 2.

Примери:
1. С променливата a от примера по-горе са свързани индексираните променливи a[0], a[1], a[2], a[3] и a[4], които са от тип int.
2. С променливата b са свързани индексираните променливи b[0], b[1],…, b[9], които са от тип double.
3. С променливата x са свързани индексираните променливи x[0], x[1],…, x[19], които са от тип enum {FALSE, TRUE}.

Дефиницията на променлива от тип масив не само свързва променливата с множеството от стойности на указания тип, но и отделя определено количество памет (обикновено 4B), в която записва адреса в паметта на първата индексирана променлива на масива. Останалите индексирани променливи се разполагат последователно след първата. За всяка индексирана променлива се отделя по толкова памет, колкото базовият тип изисква.
Пример:
ОП
а a[0] a[1] … a[4] b b[0] b[1] … b[9] …
адрес - - - адрес - - -
на a[0] на b[0]
4B 4B 4B … 4B 4B 8B 8B … 8B

За краткост, вместо “адрес на а[0]” ще записваме стрелка от а към a[0]. Съдържанието на отделената за индексираните променливи памет е неопределено освен ако не е зададена дефиниция с инициализация. Тогава в клетките се записват инициализиращите стойности.
Пример: Разпределението на паметта за променливите p и q, дефинирани в примерите по-горе, е следното:

ОП
p p[0] p[1] p[2] p[3]
1.25 2.5 9.25 4.12

q q[0] q[1] q[2] q[3] q[4]
1 2 3 0 0

Операции и вградени функции

Не са възможни операции над масиви като цяло, но всички операции и вградени функции, които базовият тип допуска, са възможни за индексираните променливи, свързани с масива.
Пример: Недопустими са:
int a[5], b[5];
cin >> a >> b;
a = b;
а също a == b или a != b.
Операторът
cout << a;
извежда адреса на a[0].

Задачи върху тип масив

Задача 48. Да се напише програма, която въвежда последователно n числа, след което ги извежда в обратен ред.

Програма Zad48.cpp решава задачата.
Program Zad48.cpp
#include <iostream.h>
int main()
{double x[100];
cout << "n= ";
int n;
cin >> n;
if (!cin)
{cout << "Error, Bad input! \n";
return 1;
}
if (n < 0 || n > 100)
{cout << "Incorrect input! \n";
return 1;
}
for (int i = 0; i <= n-1; i++)
{cout << "x[" << i << "]= ";
cin >> x[i];
if (!cin)
{cout << "Error, Bad Input! \n";
return 1;
}
}
for (i = n-1; i >= 0; i--)
cout << x[i] << "\n";
return 0;
}

Изпълнение на програма Zad48.cpp

Дефиницията double x[100]; води до отделяне на 800B ОП, които се именуват последователно с x[0], x[1], …, x[99] и са с неопределено съдържание. Освен това се отделят 4B ОП за променливата x, в които записва адресът на индексираната променлива x[0]. Следващият програмен фрагмент въвежда стойност на n (броя на елементите на масива, които ще бъдат използвани). Операторът
for (int i = 0; i <= n-1; i++)
{cout << "x[" << i << "]= ";
cin >> x[i];
if (!cin)
{cout << "Error, Bad Input! \n";
return 1;
}
}
въвежда стойности на целите променливи x[0], x[1], …, x[n-1]. Всяка въведена стойност е предшествана от подсещане. Операторът
for (i = n-1; i >= 0; i--)
cout << x[i] << "\n";
извежда в обратен ред компонентите на масива x.

Забележка: Фрагментите:
… и …
cout << "n= "; int n = 10;
int n; int x[10];
cin >> n;
int x[n];
…
са недопустими, тъй като n не е константен израз. Фрагментът
…
const int n = 10;
double x[n];
е допустим.