I. Основи на езика C++ Въведение Произход на езика C++



страница1/4
Дата17.09.2016
Размер0.63 Mb.
  1   2   3   4
I.Основи на езика C++

1.Въведение

1.1.Произход на езика C++

Първото нещо, което прави впечатление на “новака” – това е името на езика. Дали има езици за програмиране C, C+ или C-? Може би съществуват езици А и В?

Въпреки, че отговорът на повечето от тези въпроси е отрицателен, то все пак съществува език В, но той не възниква от езика А, а от BCPL. Езикът С възниква от езика В, а С++ се появява на основата на С. Двата знака “+” към името са добавени, заради оператора “++”, който в С се използва много често.

Езикът С е разработен от Денис Ритчи, сътрудник на компанията AT&T Bell Laboratories, през 1970г. Отначало езикът С е бил написан за създаване и поддръжка на операционната система UNIX. (до този момент всички програми на операционната система UNIX са били написани или на асемблер, или на В, разработен от Кен Томпсън – създателят на UNIX.) Езикът С и средата UNIX дотолкова си паснали, че скоро всички програми, работещи под UNIX, били написани на С. Популярността на езика се увеличила дотолкова, че той бил пригоден за работа и с други операционни системи. Въпреки това езикът С не бил лишен от недостатъци.

Основна особеност на езика е, че бидейки език от високо ниво, той съхранява много черти на език от ниско ниво. В това се състоят неговите силни и едновременно с това – слаби страни. Както и асемблер, С може непосредствено да управлява паметта на компютъра. От друга страна С притежава черти на езиците от високо ниво; затова програмите на С се четат и създават по-леко, отколкото на асемблер. От друга страна обаче, езикът има значително по-малки възможности за автоматична проверка на програмата, отколкото някои други езици от високо ниво.

За да преодолее тези и някои други недостатъци на С Бярн Страуструп от AT&T Laboratories разработва през 1980г езика за програмиране С++ - усъвършенстван език С с добавени възможности за обектно-ориентирано програмиране. По-голямата част на С е подмножество на С++, т.е. повечето програми на С се явяват и програми на С++. Обратното, разбира се не е вярно.



1.2.Компилатори

За програмите, написани във вид на последователност от 0 и 1, казваме, че са написани на машинен език – единствения разбираем за компютъра език. При езиците от високо ниво обаче, за да бъде изпълнена програмата е необходимо тя да се преведе на машинен език. Преводът на инструкциите се осъществява чрез специални програми, наречени компилатори.




Компилаторпрограма, превеждаща написана на език от високо ниво програма, в запис на машинен език.

Текстът на С++ програмата наричаме изходна програма или още източник на кода, а преведената на машинен език програма - обектен код (код).

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

В повечето С++ програми се използват оператори (например операторите за вход и изход), които вече са били написани и скомпилирани по-рано. При превода на програмата на машинен език обектният код на такива стандартни процедури се присъединява към обектния код на вашата програма. Това се изпълнява от друга програма, наречена свързваща програма (linker).



Свързване – процесът на съединяване на обектния код на програмата с обектния код на стандартните процедури. Изпълнява се от свързваща програма, наречена linker.

При много съвременни системи за програмиране свързването става автоматично.

фиг. 1

Взаимодействие на компилатора и свързващата програма
Програма на С++

Компилатор

Обектен код на програмата

Свързваща програма

Обектен код на стандартните подпрограми

Готов за изпълнение машинен код



1.3.Програмиране и решаване на задачи

Алгоритъм – последователност от точни инструкции за решаване на задачата

Процесът по написването на една програма се разделя на две фази- фаза на решаване и фаза на реализация. Резултатът от фазата на решаването е алгоритъма. След това той се превежда на език за програмиране – фаза на реализацията.


фиг. 2

Фаза на решаване

Фаза на реализация

Начало


Постановка на задачата

Създаване на алгоритъм

Проверка на алгоритъма на хартия

Превод на алгоритъма на език за програмиране

Тестване на програмата

Готова програма


1.4.Жизнен цикъл на програмното обезпечаване

Създателите на мощни програмни продукти (като компилатори и операционни системи) обикновено делят процеса на създаване на програмата на шест етапа, характеризиращи жизнения цикъл на програмното обезпечаване




  1. Анализ и точно определяне на проблема (постановка на задачата);

  2. Разработка на програмата (разработка на алгоритъма);

  3. Реализация на алгоритъма (превод в машинен код);

  4. Тестване;

  5. Поддръжка и развитие на системата;

  6. Стареене.

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

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

въпроси и задачи:


  1. Опишете алгоритъм за отделяне на по-леката от девет, външно еднакви монети, само с помощта на аптекарски везни (без теглилки). Може ли алгоритъмът да се подобри (т.е. да се намали броят на операциите)?

  2. Избройте шестте етапа на жизнения цикъл на програмата


2.Структура на елементарна С++ програма

2.1.Структура на елементарна С++ програма
Да разгледаме следната програма:

#include


int main()

{

int number_of_klasses, students_per_klass, total_students;


cout<<"Въведете броя на класовете и натиснете Enter \n";

cin>>number_of_klasses;

cout<<"Въведете броя на учениците във всеки клас: \n";

cin>>students_per_klass;


total_students = number_of_klasses * students_per_klass;
cout<<"Във вашето училище има общо ";

cout<

cout<<" ученици.\n";
return 0;

}

Началото и края на програмата съдържат някои елементи, на които ще се спрем подробно по-късно. Програмата започва със следното:


#include
int main()

{
Засега това ще означава “Програмата започва тук.”. Съответно тя завършва със следните два реда:


return 0;

}
Редовете между началните и крайните инструкции представляват тялото на програмата.

Инструкцията
int number_of_klasses, students_per_klass, total_students;
се нарича обявяване на променливи. Тя съобщава, че думите number_of_klasses, students_per_klass и total_students ще се използват като имена на променливи. Първата дума int е съкращение от думата integer и означава,че тези променливи могат да приемат само целочислени стойности. Тя съобщава на компютъра и колко памет трябва да отдели за запомняне на тези стойности.

Останалите инструкции се наричат оператори. Всеки оператор в С завършва с “;”.


Забележка: За разлика от някои други езици в С символа “;” не служи за разделяне на два оператора, а е част от самия оператор
cin е оператор за вход, а cout – за изход на данни. Стрелките << и >> показват посоката, в която се движат данните. Ако под думата cout разбираме изходното устройство (монитора), то стрелките показват, че текстът в кавичките трябва да се придвижи от програмата към монитора. знакът \n съобщава на компютъра, че след извеждането на текста, той трябва да се подготви да пише на нов ред.

Аналогично, ако под думата cin разбираме стандартното входно устройство (клавиатурата), то стрелките в реда

cin>>number_of_klasses;

показват, че входната информация трябва да се придвижи от клавиатурата към променливата number_of_klasses.



задача:

Да се набере, компилира и тества горната програма.


Не е трудно да се досетим, че знака “=” служи за присвояване на стойност. Операторът се изпълнява отдясно наляво: първо се пресмята стойността на израза в дясната част на знака “=” и след това тази стойност се записва като стойност на променливата, намираща се вляво от знака “=”. Със знака “ * означаваме операцията умножение.
Забележка: При неправилно използване на наклонената черта в литерала \n (напр. замяна с ” /”) компилаторът няма да даде съобщение за грешка. Но няма и да се изпълни инструкцията за преминаване на нов ред.

При някои системи последният изходен оператор трябва задължително да завършва с \n .
Структура на елементарната С++ програма

#include


int main()

{

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


Оператор_1

Оператор_2

...

Оператор_N


return 0;

}

А сега да се върнем в началните редове на програмата.



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

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

int main()

{

По-правилно е да се каже,че тук започва главната функция на програмата. Скобите “{” и ”}” означават съответно начало и край на блок от оператори. Препоръчва се да се поставят в отделни редове, една под друга.



Последния оператор

return 0;

означава край на програмата. Не е задължително да бъде последен. Някои компилатори допускат отсъствието му, докато за други той е задължителен. Препоръчва се винаги да се пише. Операторът return се нарича възвръщаща оператор. Числото 0 има важно значение, на което ще се спрем по-късно.

2.2.Видове грешки при създаване на програма



                  1. Синтактични грешки – грешки при нарушаване на синтактичните правила на езика. Напр. пропуск на “;” и др. При наличие на такава грешка компилаторът извежда съобщение за грешка (error message) или предупреждение (warning message) и показва приблизителното местонахождение на синтактичната грешка. Понякога компилаторът може да “сгреши” характера на грешката.



                  1. Грешки по време на изпълнение. Напр. опит за деление на 0. Синтактична грешка няма, но операторът не може да бъде изпълнен. И при този вид компилаторът издава съобщение.



                  1. Логически грешки – грешки в алгоритъма, технически грешки (напр. замяна на една операция с друга) и т.н. Компютърът не може да “улови” такава грешка

задачи:

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

                  2. Напишете програма. която изписва името Ви, оградено в рамка по следния начин:

    Пепи

    За да изградите рамката използвайте символите | – +.



                  1. Напишете програма. която намира сумата и произведението на първите десет естествени числа

                  2. Напишете програма, която извежда съобщение “Hallo, my name is…” (на мястото на многоточието запишете Вашето име). След това на нов ред програмата трябва да извежда “What is your name?”. И накрая отново на нов ред да се извежда “Good day, dear ...(името на потребителя)”

Упътване: Тази програма е значително по-трудна от предишните, защото използва все още непознати елементи.За да я реализирате включете директивата

#include

За въвеждането и извеждането на името на потребителя ще Ви трябва променлива от тип символен низ (типовете данни и променливите ще научите в следващите уроци), която се обявява по следния начин:

string name;

Прочитането на името, въведено от потребителя става чрез оператора getline(cin, name); , a изписването му на екрана – по познатия вече начин: cout<
3.Променливи и присвояване на стойност

3.1.Променливи в езика С++

Да разгледаме следната програма:


#include

int main()

{

int number_of_bars;



double one_kkal, total_kkal;
cout <<"Въведете броя на бонбоните в една кутия:\n";

cout <<" и енергийната стойност на един бонбон. \n";

cin >>number_of_bars;

cin >>one_kkal;


total_kkal = one_kkal*number_of_bars;
cout <<"Общата енергийна стойност е "<cout <<"Отворете друга кутия\n";

cout <<”Въведете броя на бонбоните в кутията:\n";

cout <<" и енергийната стойност на един бонбон. \n";

cin >>number_of_bars;

cin >>one_kkal;
total_kkal = one_kkal*number_of_bars;
cout <<"Общата енергийна стойност е "<cout <<" Може би е по-добре да изядете една ябълка.\n";

return 0;


}

Думите number_of_bars, one_kkal и total_kkal се явяват имена на променливи.Както и в математиката променливата може да приема различни стойности. Тези стойности се записват в определен участък от паметта, който е единствен за всяка променлива. Затова в даден момент там може да има само една стойност. Например, ако в програмата въведем, че в първата кутия има 15 бонбона, а във втората – 20, променливата number_of_bars отначало ще приеме стойност 15, но след това тази стойност ще бъде заменена с 20. В такъв смисъл променливата представлява по-скоро участък от паметта, който може да бъде намерен по нейното име. Размерът на този участък се определя от типа на променливата.

Типът на променливите се указва при тяхното обявяване. В случая променливата number_of_bars е от тип int, а променливите one_kkal и total_kkal – от тип double. Променливите от тип int могат да приемат само целочислени стойности , а от тип double – рационални. Освен това за всяка променлива от тип int трябва да се отделят по 2 (за 16-битовите компилатори) или по 4 (за 32-битовите) байта памет, а за всяка променлива от тип double – по 8 байта.

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

Идентификаторът е дума, която се използва за означаване на променливи, константи, запазени думи и други елементи на езика. За да бъде дадена дума идентификатор в С++, тя с буква или символ за подчертаване, а после да следват букви, цифри или символ за подчертаване.

Препоръчва се имената на променливите да са мнемонични, т.е да носят информация за тяхното предназначение.


Внимание!

Компилаторът на С++ различава главни и малки букви. Напр. думите rate, RATE и Rate идентифицират три различни променливи. Прието е имената на променливи в С++ да се пишат с малки букви.
Идентификаторът в С++ може да бъде с произволна дължина, но някои компилатори възприемат само определен брой знаци.
Съществува определен клас идентификатори, наречени ключови (запазени) думи. Те се използват само за специални цели.

Пример: int, double.



3.2.Обявяване на променливи

Всяка променлива в С++ трябва да бъде обявена преди нейното използване. По този начин се съобщава на компилатора характера на информацията, която ще се пази в тази променлива, необходимото количество памет и името, чрез което програмистът има достъп до тази информация.

Това става по следния начин:
Обявяване на променлива
Синтаксис:

Тип_на променлива Име_1, Име_2, ... ,Име_N;


,където Име_1, Име_2, ... ,Име_N са имена на променливи.
Пример:

int count, number_of_trolls;

double distance;


Променливите се обявяват или непосредствено преде използването им, или в началото на програмата веднага след редовете

int main()

{

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

Чрез оператора за присвояване се дава нова или начална стойност на променлива.


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

Синтаксис:

Променлива = Израз;



Семантика:

Пресмята се стойността на израза вдясно от знака “=” и след това тя става стойност на променливата вляво.


Примери:

distance = speed * time;

count = count + 2;

sum = 0;
Изразът вдясно може да бъде константа, променлива ли израз, получен от свързването на константи и променливи чрез допустимите за типа данни операции. Тъй като операторът се изпълнява отдясно наляво, допустимо е променливата вляво да присъства и в израза вдясно. При пресмятането на израза се използва старата стойност на променливата, а резултата се записва като нова нейна стойност.



3.4.Инициализация на променлива при обявяване

Внимание: неинициализирани променливи!

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

Един от начините да се избегне това е инициализацията на променливата да става едновременно с тяхното обявяване.

Например:

int min_number = 3;

Този оператор едновременно обявява променлива min_number от тип int и й присвоява първоначална стойност 3. Обикновено при такава инициализация на променливата се присвоява константа, но по принцип това може да е произволен израз, допустим за типа на променливата. При обявяване на няколко променливи от един тип, може да се инициализират произволен брой от тях.

Пример:

double rate = 0.07, time, balance = 0.00;


Инициализация на променливи при обявяване
Синтаксис:

Тип_на_променлива Име_1 = Израз_1,

Име_2 = Израз_2,

...


Име_N = Израз_N;

,където Име_1, Име_2, ... ,Име_N са имена на променливи.


Пример:

int limit = 0, count = 10;

double distance = 9.999;
Въпроси и задачи:


  1. Как трябва да се обявят променливите cm и inch от тип int като им се присвоят нулеви стойности?

                  1. Напишете програма, която преобразува сантиметра в in_1 инча и инча в сm_2 сантиметра. Променливите cm_1 и in_2 са от тип int, а променливите in_1 и сm_2 – от тип double. (1 cm = 2.54 inch)

                  2. Какви ще бъдат стойностите на променливите а и b след изпълнението на следния фрагмент?

int a = 8, b = 3;

b = a + b;

a = b – a;

b = b – a;





                  1. По какъв друг начин могат да се разменят стойностите на две числа? Напишете програма.

                  2. Посочете грешките в следващите фрагмент

а) int n =3,

double m = 5;

б) int n =3;

double = 5;

в) double Min, Max, 3D;

г) New = Min * Max

д) P = 2(a + b);

е) a * a = area;



Решение:

а) след int n = 3 е записан знака “,”, вместо “;”

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

в) 3D не е идентификатор

г) липсва “;”

д) липсва знака за умножение – “*”

е) разменени са местата на променливата и израза при оператора за присвояване.

4.Вход и изход на информация
В С++ съществуват няколко метода за вход и изход на информация. Тук ще разгледаме входно-изходните потоци (streams). Входен поток – това е потокът на входните данни, които ще бъдат използвани в програмата. Думата “поток” показва, че за програмата не е важен източникът на информация. По-късно ще видим как с помощта на същите оператори може да се осигури вход на информация, запазена във файл. Аналогично, изходен поток – това е потокът на информацията, източник на която се явява програмата, а приемник – съответното изходно устройство (в случая - монитора).

4.1.Изход с помощта на cout

Cout е име на изходен поток, с което се означава стандартното изходно устройство (монитора), а познатият вече знак “<<” – оператор , указващ, че следващата го информация трябва да се насочи от програмата към съответното изходно устройство. Чрез комбинацията “cout <<” на екрана на компютъра могат да се извеждат стойности на променливи или текст.

Пример:

(1) int a = 5, b = 7;



cout << “a * b = ”;

cout << (a * b);

cout << “\n”;

На екрана ще се изведе:



a * b = 35
Kавичките в реда cout << “a * b = ”; указват,че информацията, заключена между тях е текстова и тя трябва да се извежда така, както е написана, докато липсата им в следващия ред – cout << (a * b); означава, че трябва да се пресметне и изведе стойността на израза a * b (в случая - 35). Някои компилатори допускат скобите да бъдат изпуснати, докато за други те са абсолютно задължителни.

Прави впечатление, че в пример (1) името на потока cout е използвано многократно, което очевидно не е удобно. Повторението му може да се избегне по следния начин:


(2) int a = 5, b = 7;

cout << “a * b = ” << (a * b) << “\n”;


В пример (2) думата cout е използвана само веднъж, а за разделител между данните, които се извеждат служи оператора “<<”.

Произволни два cout-оператора могат да бъдат обединени в един

Горното правило е в сила даже, когато операторът не може да се помести в един ред от екрана.

Пример:

(3) cout << “Който внимава в час по информатика, \n” << “ще получи награда.\n”;


Обърнете внимание, че в края на първия ред няма “;”, тъй като двата реда представляват един оператор.

Когато cout-операторът е твърде дълъг и не може да се помести в един ред от екрана, е удачно той да бъде разделен по редове от програмиста. Това става чрез вмъкването на литерала “\n” или с помощта на думата endl, наречена символ за нов ред. Пример (3) е аналогичен на следващия

Пример:


    1. cout << “Който внимава в час по информатика, “<

<< “ще получи награда.”<
Забележка:

Литералът \n задължително трябва да бъде в кавички и между символите \ и n да няма интервал. Символът endl не трябва да бъде в кавички.


Забележка:

Текстовите низове се ограждат в двойни кавички (“), а не в апострофи. Компилаторът различава четен и нечетен символ “.


Препоръка:

Желателно е последният cout-оператор да завършва със знак за преминаване на нов ред.


Някои компилатори няма да изпълнят последния cout-оператор, ако той не завършва със символ за край на ред.
За да бъде изведен празен ред е достатъчно към изходния поток да бъде насочен символ за край на ред.

Пример:


cout << “\n”, или

cout << endl;


  1   2   3   4


База данных защищена авторским правом ©obuch.info 2016
отнасят до администрацията

    Начална страница