поплавък F11 (междинно съединение Z1)

Int * х;
Int * у;
Int * Z;
х = ново междинно съединение;
у = ново междинно съединение;
Z = ново междинно съединение;
...

където X, Y, Z - указатели към паметта, всеки път функция въз съхранява в него числа. Тези числа са необходими само по време на функцията за работа, и следователно са междинни данни. В края на тази функция, трябва да се почисти заделената памет с командите на формата:

изтриване х;
изтриване у;
изтриване на Z;

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

поплавък F11 (междинно съединение Z1, Int * х, Int * у, Int * Z) <
...

Всичко! Тъй * х * у * Z - тя вече се работи аргументи, те трябва да се създаде един път преди стартиране на функцията, както и всякакви други аргументи, които се въвеждат функция. По този начин, в зависимост F11 () вече няма да се създаде един или премахване на същите променливи. По този начин, да запази паметта за тази възможност, ние ще я стартирате, след като създаде подходящите променливи. Освен това е препоръчително да се развива този подход. В нашия пример, нашата функция връща броя на плаваща запетая. Това означава, че всеки път, когато се създава променлива във функцията на типа на поплавък, който регистрира изпълнението на тази функция, а след това в края на функцията, тази променлива се унищожава. Това е, всъщност, в тялото на функцията е следното:

поплавък F11 (междинно съединение Z1, Int * х, Int * у, Int * Z)

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

невалидни F11 (междинно съединение Z1, Int * х, Int * у, Int * Z, поплавък * VIX) <
...
>

В резултат на това в рамките на нашата функция не създава никакви междинни променливи, както и функцията не връща нищо. Всичко необходимо за неговата работа се прехвърля на функцията за свой аргумент. В резултат на това всеки път, когато стартирате функцията не е необходимо всеки път да изолира и почистване на паметта. Всичко това е памет, всъщност, се откроява един път преди първия старт функция. Функция променя само на данните в паметта - аргументите, които служат за нейното въвеждане. Функцията заделя памет не е чист. По този начин, ние отделя процеса на разпределяне на паметта и процеса на работа с данни (памет). Функцията вече е само работи с данни в паметта, както и за неговото изолиране и пречистване не отговаря. Всичко това е добре, но на първо място, тук променливите, които функционират работи - е тезата си, което означава, че те не са създадени в рамките на функция - те са външни за функцията. И ако е така, тогава те могат да променят не само функцията, но и всеки друг в допълнение към тази функция. По това време, променливи, създадени вътре функции са достъпни само за самата функция, и никой друг. И второ, ако имаме нужда от много различни междинни променливи, масиви и т.н. за функция? Тя често е функция - това е голяма рутина. След това напишете всички междинни променливи като аргументи на функции не са лесни за използване. Най-малко би било добре да се съчетаят всички тези променливи в една структура и функция за въвеждане на линк към същата тази структура. В резултат на това на езиковите дизайнери направиха нещо подобно, но тя отиде още по-далеч - те са създали специална структура, наречени на класа. Клас - е форма на организиране на кода, където едно и също име (ID) също са функция на данните и че обработват. Това е функция поставя в една структура с данните, които трябва да се справят с тази функция и че сега не е необходимо да се създаде в рамките на тази функция се всеки път, когато се стартира. Ние сме в класната стая по-рано се опишат всички променливи, масиви и т.н. - Всички паметта, че имаме нужда, както в класната стая, ние се опише функциите, които са и ще работят с тези променливи (с тази памет). И дори ако функцията все още няма входните аргументи, на факта, че променливи, масиви и т.н. и функции принадлежат към една и съща структура (от същия клас) - Това казва на компютъра, че функциите на този клас могат да работят с променливи, масиви и т.н. този клас, както със собствените си аргументи. Освен това, данните са разделени в класа на частни и публични. Ако описване, например, една променлива като частен, а след това може да функционира само в този клас - и нищо друго от този клас да се промени тази променлива не могат. Това означава, че видът на частния - е, в действителност, тъй като вътрешните функции на променливите - те могат да се справят само самата функция и нищо друго! Е, от типа на данните на разположение на обществеността и тези, които не са членове на този клас - това е, тези данни ние по същество запишете резултата на функцията, която вече се интересуват от този клас - това е, Това е нещо, което ще се върне нашата функция, ако не се използва понятието клас и ще работи само с функциите. Така че, като комбинация от данни и функции, за да ги обработват в една и съща структура (получите името на класа) - това е същността на такива понятия като капсулиране. Както видяхме - това се предполага, че практиката на "премести" разработчиците на програмни езици. Оказа се, че това е оптимален, когато функцията изпълнява само набор от операции на данните. описание на данни и данните (паметта) за тези функции са разположени в отделно място от функциите. И в същото време данните функция и паметта за тях, за да образуват една структура - класа. Обект, между другото - това е конкретна реализация на даден клас. Точно както във вида на екипа:

Int - това е общото наименование на тип цяло число, и аз - това е определен променлива цяло число, което се се дължи на факта, че в горната команда стои идентификатор на тип Int. И класове. Клас - общ термин за тип строителство, обектът - специфичната дисплея на тази структура. За видове види. Също така тук. Между другото, там също е важно в следващия момент като време, свързани с класовете и видовете. Често, когато се описват видовете променливи в програмата се извършва например следното:

Това разпределя памет в съответното място за променливите I, J, K, където можем да се напише данните на даден вид. Въпреки това, ако ние имаме, например K1 клас, в които има, например, на променливи A1, B1, C1 вътр и функция обработката на тези променливи funk1 ():

клас К1 <
публичния:
междинно съединение А1, В1, С1;
невалидни funk1 ();

описанието по този начин:

Това води до факта, че обектите ще бъдат създадени X, Y, Z, който ще разпредели памет за своите променливи A1, B1, C1, където можем да се пишат на съответните данни. Така че сега можем да запишем всяко цяло число в разделите за памет с имена X.a1, X.b1, X.c1, Y.a1, Y.b1 и така нататък, т.е. доказано, че разпределена памет при подходящи 9 номера: 3 номера (А1, В1, С1) за обект X, 3 на обекта Y, 3 на обект Z - всичко е в положението с тип INT реклами, където се разпределя памет под съответните променливи. Но дали разпределя пространство памет за всяка от funk1 на функциите () на всеки обект? Тя ще бъде разпределена за съхранение Do X.funk1 (), Y.funk1 (), Z.funk1 ()? Оказва се, че има и това е логично, защото в противен случай ще имаме три пъти заделената памет за по същество една и съща функция (функция, която работи по същия начин)! И това глупаво пилеене на ресурси на компютъра. По този начин в C ++ памет за функцията за всеки един от обектите от същия клас, не се открояват - функции не се дублират при създаването на клас обекти. Това означава, че въвеждането на понятието клас, ние не просто да обедини в единна структура (клас) на данни и функции за обработка, но и на концепцията предполага отхвърлянето на дублирането на едни и същи функции в конкретните обекти от същия клас.
Следваща концепцията за обектно-ориентиран - наследство. Отново пример за обработка на изображения. Нека преди някой да създаде клас за работа с изображения. Бяхме напълно доволни от този клас, но бихме искали да видим в допълнение към възможностите за обработка на изображения, която предоставя този клас, ще има да има допълнителни функции. процедура по унаследяване и ви позволява да създадете свой собствен клас за работа с изображения на базата на съществуващ клас - нашия клас наследява всички характеристики на предишния, плюс прибавим към необходимата функция. Това е всичко. Това е много удобно, тъй като ние не трябва да се повтаря на работата по разработване на функции, които вече съществуват в съществуващ клас за нас. Ние наследяваме тези функции само чрез създаване на клас, който наследява от съществуващ клас. И в нашата програма, ние можем да използваме и двата класа предшественик и извлечения клас, и въпреки факта, че имаме две много подобен на класове на другата страна в извлечен клас, ние не пресъздадете функция, която вече съществува в класовете прародител. По този начин ние нямаме същите тези функции да се пренапише в извлечен клас - ние просто използвате функциите на предшественик клас, и в крайна сметка не се заемат отново спомена за една и съща функция в различни класове.
И накрая, полиморфизъм. Тук всичко е съвсем проста, и тази концепция е, всъщност, разработването на такива явления като претоварване на функции (наричана по-рано pregruzka предефиниране). Това е, когато една и съща функция може да се държи по различен начин в зависимост от типа на данните, които са подали за въвеждане на нея. Например, може да има определена функция на умножение и когато го предаде като аргумент числа, тя просто ги умножава, а когато аргументи са й дават матрица, а след това тази функция умножава матрицата според правилото за умножение на матрици. Това означава, че има една и съща функция, същия интерфейс (начин за взаимодействие, дисплей) се използва за умножаване на данни от различни видове. За да се организира така, че кодът същия интерфейс, използван за данни от различни видове, има специален език команда. Друг пример - на обработката на изображението. Това е, когато една и съща програма може еднакво да обработва изображения на различни формати - BMP, JPEG, GIF и т.н. в същото време не ви е грижа за формата на картината - трябва да се да се справя в дадена програма да изпълни същата операция, независимо от това, което в момента е даден формат на изображението. В крайна сметка, полиморфизъм може да създаде доста лесен за употреба интерфейс.
По този начин, обектно-ориентиран дизайн - това не е нещо, което някой произволно скалъпено. Обектно-ориентирани техники са възникнали от самата практика - по-оптимални методи на работа с информацията, това е всичко.

послепис За тези, които се интересуват от устройството на компютъра може да е препоръчително тук тази книга и по-специално главата на него - "Това, което е на компютъра" (самата книга или някои глави от нея, можете да си купите от тук).