Моля, имайте предвид, че когато описваме тялото на метод. мод () и защита () са описани заедно с техните тела директно в структурата. Но можете да направите по друг начин: да се сложи прототипите метод в рамките на структурата и функциите на определението на тялото - е структурата, както направихме с "+" оператор.
Първият метод се използва за кратки и прости методи, които вече няма да се очаква да се промени. Така дойде отчасти на факта, че описанието на класовете обикновено се поставя във файловете на заглавните, които са включени по-късно в прилагането на директивата за използване #include. Освен това, с този метод машинни инструкции, получени от компилатора при достъп до тези функции директно вкарани в преведения текст. Това намалява разходите за тяхното изпълнение, тъй като изпълнението на тези методи не е свързано с извикването на функция и механизма за връщане, увеличаване на свой ред размера на изпълнимия код (т.е. такива методи са вградени или вграден). Вторият начин е за предпочитане сложни методи. Обявена като по този начин функционират автоматично заменя със съставител в подпрограмата разговори, но когато добавите в ред ключова дума може да бъде заместен в текста като в първия случай.
Освен по-горе метод, създаването на вградени функции (метода писмено директно в структурата на тялото), има и друг начин - поставете спецификатор вградени преди метод определяне:
инлайн _3d _3d :: оператор + (_3d б)
_3d С;
c.x = х + b.x;
c.y = Y + b.y;
c.z = Z + b.z;
се върне в;
>
Сега операторът "+" ще бъде вградена функция.
Вградени функции са почти същите, както с макроикономическите параметри, но имат редица предимства пред последния. На първо място, методи вградени предоставят по-слаб метод за въвеждане на кратка характеристика на програмата. Второ, C ++ компилатор е много по-добре да се работи с вградени функции, отколкото с макроса.
Важно е да се разбере, че в текста не е команда на компилатора, а по-скоро желание да се направи вграден метод. Ако по някаква причина (например, в присъствието на оператори контур функция, комутатор, или посетете) компилаторът не се съобрази с искането, функцията ще се събират като не-инлайн.
Конструктори и деструктори
_3d vectorA;
двойно m;
vectorA.x = 17.56;
vectorA.y = 35.12;
vectorA.z = 1.0;
m = vectorA.mod ();
Въпреки това, в съответствие с принципите на обектно-ориентиран програмен като стил трябва да се разглежда погрешно, защото, на теория, всички елементи, които описват състоянието на обекта трябва да бъдат скрити вътре в нея, и е достъпна само само чрез съобщения, изпратени обект. Ако промените дефиницията на класа, дадени по _3d до следното:
ще получим "идеологически грамотен" решение. Но когато се съберат на предишната песен ще бъде диагностициран с опит за достъп член защитен клас. Това е страхотно, защото ви направи да допълни методите на класа интерфейс, можете да зададете стойности на координатите на вектора.
Следващата версия на класа може да изглежда така:
комплект () метод ви позволява да зададете някои от първоначалните стойности на координатите на вектора (и само този метод!).
Друга забележка: въпреки че X, Y и Z, се класират като защитени членове на класа, ясно основание на тези елементи на обекта предава като параметър (.. Виж метод издатък () и "+"), тя все още е разрешено.
Строителите в C ++ имат имена, които съответстват на името на класа. Конструкторът може да бъде определена от потребителя, или компилаторът ще генерира конструктор по подразбиране. Конструкторът може да се позоват пряко или косвено. Компилаторът автоматично извиква конструктора подходящо е мястото, където се определи нов обект клас. Дизайнер не връща никаква стойност, и не използва празнотата ключовата дума с описанието на дизайнер.
Функцията на реципрочен на строителя, деструктор е. Тази функция обикновено се нарича, когато един обект се изтрива. Например, ако се създаде обект динамично разпределя памет за това, той трябва да бъде освободен, когато обектът се изтрива. Местните обекти се премахват, когато те излизат от обхват. Глобални обекти се изтриват, когато програмата приключва.
C ++ деструктори се наричат "
CLASS_NAME. "Подобно на конструктор, деструктор няма стойност за връщане, но за разлика от строителя не може да се нарече изрично. Конструкторът и деструктор не може да се опише в затворена част от класа.
_3d :: _ 3d () // конструктор _3d
X = Y = Z = 0;
Cout <<'Работа конструктора _3d \n';
>
Основната ()
_3d А; // създаде обект А и инициализира нейните елементи
// A.x = A.y = A.z = 0;
A.set (3,4,0); // Сега A.x = 3.0, A.y = 4.0, A.z = 0.0
Cout <
Резултатът от програмата:
Работа _3d дизайнер
5.0
Работа деструктор _3d
Комплекти с параметри и претоварване дизайнери
клас _3d
двойни X, Y, Z;
публичния:
_3d ();
_3d (двойна initX, двойно initY, двойно initZ);
.
>;
_3d :: _ 3d (двойна initX, двойно initY, двойно initZ)
// конструктор с параметри _3d
х = initX;
у = initY;
Z = initZ;
Cout <<'Работа конструктора _3d \n';
>
Основната ()
_3d А; // създаде обект А и инициализира нейните елементи
// A.x = A.y = A.z = 0;
A.set (3,4,0); // Сега A.x = 3.0, A.y = 4.0, A.z = 0.0
_3d B (3,4,0); // създаде обект Б и инициализира нейните елементи
// B.x = 3.0, B.y = 4.0, B.z = 0.0
>
Такъв начин на извикване на конструктора е стенограмите изрази
За разлика от строителя, деструктор може да има параметри. Това е разбираемо, тъй като няма механизъм трансфер параметър премахва обекта.
В този пример, че е лесно да се разбере това, което може да бъде причинено от нуждата за претоварване конструктори. Това е един от претоварване, тъй като ние говорим за функциите, които имат същите имена, но различни списъци на параметрите. Основният смисъл на претоварване конструктори е да се даде на програмиста най-подходящият метод обект инициализация.
В нашия пример, най-често срещаните варианти претоварване конструкторите, т.е. параметри на конструктора и конструктор с параметри. Обикновено, в програмата има са необходими и двете от тези видове, с параметри, като конструктор е по-удобно, когато се работи с единични обекти, но не може да се използва при инициализация на елементите на динамичните обект масив (за статичен масив може).
Въпреки конструктор може да бъде претоварен толкова пъти, колкото искате, по-добре е да не се злоупотреби с него. Дизайнер Не претоварвайте само за най-често срещаните ситуации.
Присвояване на обекти
клас ClassName1
Int А, В;
публичния:
нищожен комплект (инт иа, вътр иб)
>;
клас ClassName2
Int А, В;
публичния:
нищожен комплект (инт иа, вътр иб)
>;
Така че опитът да се изпълни
ClassName1 С1;
ClassName2 c2;
с2 = С1;
В резултат на програмата получи "c2.b = 111", а не 11, както се очаква.
претоварен оператор задача
За да се избегне такова неразбирателство, използвайки оператора за присвояване на претоварване, които изрично описано (т.е., контролирани) процеса елементи прехвърляне на данни от един обект на съответните елементи на един обект на данни.
Но тъй като сега ще погледне към нашия пример на триизмерна вектор.
Би било наивно да се предположи, че за всеки нов тип променлива _3d създава копие на функцията, която изпълнява операторите "+" и "=". Всяка функция е представена в един екземпляр, и се обадете на процеса на получаване на скрит параметър - указател към копието на променливата, за която е издаден. Този индекс е това име. Ако променливата Ви е описан в функция, а не глобален, се счита, че той е член на структурата и принадлежи на работа променливата това. Поради това, изпълнението на операторите слязохме на пътя към полетата на структурата, за която ще се нарича оператора.
Аргументите на функциите оператори да действат операнди и връщане стойност - в резултат на прилагането на оператора. По-специално за оператора "=" е необходимо да се позволи последващо прехвърляне (А = В = С). Binary оператори имат един аргумент - втората показалеца преминава през това. Унарни, съответно, една - тази.
Прехвърляне на функции и връщане на предмета
Обектите могат да бъдат прехвърлени към функционира като аргументи по същия начин, както и други видове данни се предават. Всички тези, които вече са използвали, когато изпълняват методи klassa_3d. където параметрите на прожекционни техники (.), оператор + (.) и оператор = (.) преминава тип обект _3d.
Трябва да се помни, че C ++ метода параметър преминаване, по подразбиране е прехвърлянето на обекти по стойност. Това означава, че в рамките на функцията създава копие на обекта - аргумент и това копие, а не самия обект, използвайте функцията. Ето защо, копието на промените на обекта в зависимост не влияят на самия обект.
Когато един обект се предава към функция има нов обект. При активиране на функцията за работа, която е била прехвърлена на обекта е завършена, копието на аргумента, се отстранява. И това е, което трябва да се обърне внимание тук. Как е копието на обекта и деструктора на обекта е задействана, ако, когато си свали копие? Фактът, че копие от деструкторът се вика, може би, разбираемо, защото на обекта (копие на обекта, който се предава като параметър) излиза от обхвата. Но нека не забравяме, че обектът в самата функция - Bit-мъдър, че е копие на преминал обекта, което означава, че ако обектът съдържа, например, указател към някои динамично разпределена площ памет при копиране на обект се създава, сочейки към едно и също място на паметта. И веднага след като деструктор се извиква, което обикновено се приема, за да освободите паметта, освободен района памет, посочи от предприятието-на "оригинала", което води до унищожаване на оригиналния обект.
клас име на класа
публичния:
Име на класа ()
Cout <<'Работа конструктора \n';
>
Име на класа ()
Cout <<'Работа деструктора \n';
>
>;
невалидни е (име на класа о)
Cout <<'Работа функции f \n';
>
Тази програма ще доведе до следното
Дизайн работа
функция на работа е
работа деструктор
работа деструктор
Конструкторът се нарича само веднъж. Това се случва, когато създавате С1. Въпреки това, деструктор се задейства два пъти, веднъж за копие о. втори път за В1 обект. Фактът, че деструкторът се вика два пъти, може да бъде потенциален източник на проблеми, например, за обекти, които деструктор пресата динамично разпределени площ памет.
Подобен проблем възниква при използване на обекта като стойността за връщане.
За да функционира може да се върне един обект, е необходимо: първо, да декларира функция, така че неговото значение е от типа връщане на класа, и второ, да се върне на обекта с помощта на редовна връщане оператор. Въпреки това, ако обектът се връща съдържа деструктор, в този случай, има подобни проблеми с "неочакван" унищожаването на обекта.
клас име на класа публичен:
Име на класа ()
Cout <<'Работа конструктора \n';
>
Име на класа ()
Cout <<'Работа деструктора \n';
>
>;
Име на класа е ()
Име на класа OBJ;
Cout <<'Работа функции f \n';
върнете OBJ;
>
Тази програма ще доведе до следното
Дизайн работа
Дизайн работа
функция на работа е
работа деструктор
работа деструктор
работа деструктор
копиране конструктори
Конструктор се нарича два пъти: за C1 и OBJ. Въпреки това, има три деструктори. Как така? Ясно е, че един деструктор унищожава C1, друг - OBJ. "Excess" деструктор предизвикателство (на втория ред) се нарича за така наречения временен обект. който е копие на върнатия обект. Това копие се образува, когато функция връща обект. След функцията връща стойността му, извършено временно обект деструктор. Ясно е, че ако деструктор например, освобождава динамично заделената памет, унищожаването на временен обект ще доведе до унищожаване на върнатия обект.
Един от начините да се получи около този проблем е да се създадат специални дизайнери тип - Копие конструктори. копие конструктор и копие Конструкторът Ви позволява да се определи точно реда на създаването на копие на обекта.
Всяко копие конструктор има следния вид:
име на класа (конст име на класа OBJ)
. // конструктор тяло
>
клас име на класа
публичния:
Име на класа ()
Cout <<'Работа конструктора \n';
>
Име на класа (Конст име на класа OBJ)
Cout <<'Работа конструктора копирования\n';
>
Име на класа ()
Cout <<'Работа деструктора \n';
>
>;
Основната ()
Име на класа С1; // конструктор повикване
Име на класа C2 = С1; // повикване копие конструктор
>
Забележка: На строителя на копие не се отразява на оператора на задача.
Сега, когато имате конструктор копие, можете спокойно да премине обекти като параметри на функции и да се върне обекти. В този случай, на броя на обажданията от дизайнери ще съответства на броя на обажданията, деструктор, а тъй като копия на процеса на обучение се е превърнала в контролирани, значително намаляване на вероятността от неочакван унищожаване на обекта.
Показалки и препратки към обекти
До сега, достъп до членовете на обекта се извършва с помощта на операцията ".". Това е правилно, ако се работи с даден обект. Въпреки това достъпът до членовете на обекта може да се извърши и чрез указател към обекта. В този случай, операцията обикновено се прилага стрела "->".
Указател към обект е обявен по същия начин, както е указател към променлива от всякакъв вид.
анулира ToZero (_3d * ВЕЦ)
В C ++, което можете да направите същото нещо, без да използвате указатели, като използвате връзките.
нищожен ToZero (_3d ВЕЦ)
vec.set (0,0,0); // използва "."
>
За разлика премине като параметър на обекта, с използване на еталонен параметър показва, че функцията, която е предала параметъра за манипулиране, не е копие на предадения обект, а именно тези, предадени обект.
_3d _3d :: оператор = (_3d б)
Използва се като връщане на стойност от нея осигурява връзката, която се върнаха в резултат на тази функция е именно обекта, който призовава операцията "=", а не копие.
Свързани статии