Работа с показатели понякога може да доведе до грешки, ако те не се използват много внимателно. Така, например, може да бъде трудно, ако сте пропуснали да ги инициализира, забрави да ги премахнете, след употреба и отстраняване на два пъти един и същ индекс.
Основният проблем с указатели е, че когато се работи с динамична памет е необходимо да се разработи система, която ще управлява своя собствена памет. Тя ще знаят къде да разпредели памет, и където се извършва допускането, което не винаги е тривиална задача. Понякога се развива приложения са толкова сложни, че не е възможно да се освободи паметта заета от точно на същото място и са идентифицирани. И това често е трудно да се определи срок на ресурса.
Класове в C ++ - «интелигентно». За разлика от езика С в допълнение към методите, те имат конструктори и деструктори. По този начин, има понятието "живот време" - по време на извикване на конструктора да се обадите на деструктор. Въпреки че в действителност се смята за обект, за да бъде жив след пълното прилагане на дизайнера преди деструкторът се вика. Не можем да кажем, че обектът е жив в момента на тяхното изпълнение, тъй като не е гарантирано, че всички полета се инициализират и нетривиален да се работи с тях може да бъде изпълнен с проблеми.
невалидни Foo () А а;
// полезна работа
// наричаме деструктор
>
невалидни Foo () А а;
// полезна работа
// наричаме деструктор
>
// полезна работа
>
бар (А ());
// деструктор ще
// нарече
// завършена
// изпълнение на бар ()
В динамичното разпределяне на обекта ще съществува, докато не премахнахме. Когато програмата свърши изпълнението му, никой няма да се обади деструктора на обектите, които са не един програмист не се отстранят, така че ако има някакво важно код (като намаляване на връзката), то няма да бъде изпълнена. В този случай, на жизнения цикъл на един обект е ограничен до отстраняването на показалеца използване изтриете. Ако обектът не е отстранена преди освобождаването на неговата линия на очите, тя се превръща в "зомби" - тя съществува, но не може да се получи достъп до нея.
невалидни Foo () А а = нов А ();
// обект няма да бъде унищожена, докато повикването изтриване
>
"Смарт Index" свързва живота на обекта на куп с жизнения цикъл на обекта, разпределени в стека.
Помислете кода сравнение, която работи с конвенционални и нововъзникващите умен показалеца. Ние ще се основава на вече разработена преди клас BIGINT.
BIGINT * р = нов BIGINT ();
(* Р) = N;
//.
низ ул = р> ToString ();
//.
изтриване на р;
Проблемът с помощта на конвенционално показалка е, че навсякъде в текста, може да бъде причинено от връщане. и в този случай, програмата няма да достигне точката на изхвърляне. Въпреки това, изтриването следва да се приложи, когато е имало разпределение на паметта с нови. Можете да се елиминира необходимостта да го наричат ръчно с помощта на умен показалеца, за да общуват с синтаксиса, който е подобен на синтаксиса на комуникация с обикновен показалка. В този случай паметта могат да бъдат прехвърлени за почистване на деструктор умен показалеца.
Ние описваме класа разработена интелигентна показалка.
лично:
BIGINT * ptr_;
публичния:
BigIntPtr (BIGINT * р = 0);
BigIntPtr ();
BIGINT оператор * () конст;
BIGINT * оператор -> () конст;
лично:
BigIntPtr (BigIntPtr Конст );
BigIntPtr оператор = (BigIntPtr конст );
>;
BigIntPtr :: BigIntPtr (BIGINT * р): ptr_ (п)>
BigIntPtr () изтрива ptr_;
>
BIGINT BigIntPtr :: оператор * () Конст връщане * ptr_;
>
BIGINT * BigIntPtr :: оператор -> () Конст връщане ptr_;
>
Трябва също да се отбележи, че в съответствие с мнемоничен правило при определяне на деструктор трябва също така да се определи строителя копие и оператора задача. Това се дължи на факта, че ако искаме да унищожи обекта не е тривиален (например, за да се освободи по-рано заделената памет), дори и при копиране от конструктор или прехвърляне може да предизвика проблеми.
Унарни "звездичка" - константа, а се връща не-конст справка. Както разработен от умен показалеца трябва да се държи като нормален показалка, тогава ние трябва да се даде възможност за промяна на обекта, към който те се позовават. Въпреки това, ние разбираме, че много умен показалеца в този случай не се променя.
Няма нужда да се справят с изключение, ако умен указател към всичко, което не е посочен (т.е. ptr_ нула). Фактът, че нормалната показалеца и не реагира на такова поведение, и това не е ясно какво трябва да се върне в този случай е умна.
"Arrow" оператор трябва да връща указател. Въпреки че в действителност, това може да се възстанови всичко, което има изявление, "стрела", но след това се обадите този оператор ще се повтаря, докато, докато най-накрая, да не се връща на показалеца.
деструктор Смарт показалка ни освобождава от необходимостта да се пречисти паметта, защото го прави сам. По този начин, обект на които интелигентни показалеца точки, ще бъдат унищожени веднага след излизане от блок умен показалеца видимостта.
Тази концепция се нарича RAII - Ресурсен придобиване е Инициализация (разпределение на ресурсите е Инициализация). Това означава, че подготовката за работа, ние гледаме на обекта в разпределението на паметта за него, и го прави отговорен за връщането на паметта на негово унищожение. Като пример, свързвания към база данни, поискани пристанища mutexes в едновременни приложения. Ако обектът не се връща искания инициализация ресурс, никой след него няма да може да го използва.
Код, който е по-горе има много недостатъци. На първо място, като указател не може да бъде променено. Това може да се коригира чрез определяне на оператор за присвояване, от дясната страна на който е указател към обекта, който искате.
Така, че не може да съществува два указатели към един и същ обект. Деструкторът за първи умен показалеца унищожи обекта, а втората показалка деструктора се опитва да направи същото. В този случай, няма да има отстраняване двойна грешка.
В допълнение, не е възможно да се провери, не се отнася за това дали такъв умен показалеца до нула.
Също така, тези показатели не могат да бъдат сравнявани с конвенционалните показатели. Ако ги премине във функцията сравнение, ако строителят, който се нормално показалка не е обявена като изрично. тя ще създаде умен показалеца, и след напускането на временен обект деструктор ще премахне обекта.
Концепцията за такъв указател, наречен с обхват Pointer - показалка обхват. Този интелигентен показалеца може да се използва само в блока, който е обявен.
Друго изпълнение - Споделено Pointer, сподели показалка. Нейната разлика се състои в това, че този индекс може да бъде копиран. В този случай, на самия обект се изтрива само когато последният показалеца е унищожена, отнасящи се до него. Това е възможно чрез използване на референтния брой.
Идеята е следната: когато се създава интелигентен показалка, той от своя страна създава препратка брой, номер, който се съхранява на куп, като посочва броя на умни указатели, които се отнасят за даден обект. При копиране на показалеца е не само указател към обект копие, но също така и указател към този брояч, и стойността му се увеличава. С унищожаването на спадове стойност на брояча умен показалеца. Ако стрелката е била унищожена от последния собственик на обекта, а обектът се премахва, също.
Друг вариант е да се създаде общ указател допълнителен обект в купчината, която съдържа както брояча и позоваване на постоянен обект. По този начин, когато се копира копиране, само един индекс, всеки умен показалка ще се отнася само за един обект с брояч и препратка към оригиналния източник.
Такива знаци вече може да бъде назначен един до друг, изпраща копие до функцията за сравнение и др.
Свързани статии