Phenquestions
Необходимо е известно време за създаване на обект. Необходимо е известно време, за да убиете обект. Когато се говори за обект, се включват две неща: местоположението, което е хранилището, и стойността. Значението на живота и продължителността на съхранението са сходни; но продължителността се вижда повече от гледна точка на местоположението, отколкото от гледна точка на стойността. Продължителността на съхранението е времето от когато дадено местоположение е свързано с обект до момента, когато местоположението е отделено от обекта.
Останалата част от тази статия илюстрира живота на обекта и накратко обяснява различните продължителности на съхранение. Трябва да имате основни познания по C ++, за да разберете тази статия. Трябва също така да имате познания в обхвата на C ++.
Съдържание на статията
- Илюстрация на живота на обекта
- Продължителност на съхранението
- Продължителност на автоматичното съхранение
- Динамично време на съхранение
- Продължителност на статичното съхранение
- Продължителност на съхранението на нишката
- Заключение
Илюстрация на живота на обекта
Обмислете следната програма:
#includeизползване на пространство от имена std;
int main ()
ако (1 == 1)
int x;
x = 1;
въглерод;
y = 'A';
Cout << x << y << '\n';
връщане 0;
Изходът е 1А .
Животът на обекта приключва, когато излезе извън обхвата. Животът на обекта x започва от “x = 1;” и завършва в края на if-local-scope. Животът на обекта y започва от “y = 'A';” и завършва в края на if-local-scope. Преди и двата обекта да умрат, те се използват в изявлението на cout .
Продължителност на съхранението
Продължителността на съхранението се определя от една от следните схеми: автоматична продължителност на съхранение; динамична продължителност на съхранение; статична продължителност на съхранение; продължителност на съхранение на нишка. Категориите за продължителност на съхранението се прилагат и за референции.
Продължителност на автоматичното съхранение
Ако променлива не е декларирана изрично като static, thread_local или extern, тогава тази променлива има автоматично време на съхранение. Примери са x и y по-горе. Продължителността на такива променливи приключва, когато излязат извън обхвата. Следващата програма илюстрира продължителност на автоматичното съхранение за референция и указател в глобалния обхват.
#includeизползване на пространство от имена std;
int x = 1;
int & m = x;
char y = 'A';
char * n = & y;
int main ()
Cout << m << *n << '\n';
връщане 0;
Изходът е 1А .
Продължителността на m започва от „int & m = x;“ и завършва в края на програмата. Продължителността на n започва от „char * n = & y;“ и завършва в края на програмата.
Динамично време на съхранение
Безплатен магазин
В съвременен компютър могат да се изпълняват едновременно повече от една програма. Всяка програма има своя част от паметта. Останалата част от паметта, която не се използва от никоя програма, е известна като безплатен магазин. Следният израз се използва за връщане на местоположение за цяло число от безплатния магазин
нов интТова местоположение (съхранение) за цялото число, върнато, все още трябва да бъде идентифицирано чрез присвояване на указател. Следният код илюстрира как да използвате показалеца с безплатното съхранение:
int * ptrInt = нов int;* ptrInt = 12;
Cout<< *ptrInt <<'\n';
Изходът е 12 .
За да сложите край на живота на обекта, използвайте израза delete, както следва:
изтриване на ptrInt;Аргументът за израза за изтриване е указател. Следният код илюстрира използването му:
int * ptrInt = нов int;* ptrInt = 12;
изтриване на ptrInt;
Указателят, създаден с новия израз и изтрит с израза за изтриване, е с продължителност на динамично съхранение. Този указател умира, когато излиза извън обхвата или се изтрива. Продължителността на обекта в предишния код започва от “* ptrInt = 12;” и завършва в края на декларативния регион (обхват). В изразите new и delete има повече неща, отколкото е обсъждано тук - вижте по-късно.
Продължителност на статичното съхранение
Статичен обект
Обект, обявен за статичен, се държи като обикновения обект, с изключение на това, че продължителността на съхранението му започва от момента, в който е инициализирана до края на програмата. Той не може да се види извън неговия обхват, но косвено може да се използва извън неговия обхват.
Помислете за следната програма, която трябва да брои от 1 до 5 (не тествайте програмата):
#includeизползване на пространство от имена std;
int fn ()
int stc = 1;
Cout << " << stc;
stc = stc + 1;
ако (stc> 5)
връщане 0;
fn ();
int main ()
fn ();
връщане 0;
Резултатът е 1 1 1 1 1 1 1 1 1 ... и никога не завършва. Определението на функцията е повтаряща се функция; което означава, че продължава да се самоизвиква, докато не бъде изпълнено условие.
Решението е да направим обекта stc статичен. След като статичният обект е инициализиран, неговата стойност не може да бъде променяна, докато програмата приключи. Следващата програма (която можете да тествате), която е същата като горната, но сега със stc, направена статична, отброява от 1 до 5:
#includeизползване на пространство от имена std;
int fn ()
статичен int stc = 1;
Cout << " << stc;
stc = stc + 1;
ако (stc> 5)
връщане 0;
fn ();
int main ()
fn ();
връщане 0;
Резултатът е: 1 2 3 4 5 .
Забележка: Продължителността на статичен обект започва, когато обектът е инициализиран, и завършва в края на програмата. Междувременно обектът може да се използва индиректно, от различен обхват. След като статичният обект е инициализиран, първоначалната му стойност не може да бъде променена, дори ако дефиницията му е преоценена. В горния код stc не се нулира, следващия път, когато се извика. Следващият път, когато бъде извикан, той се увеличава с „stc = stc + 1;“.
Член на статичните данни
Набор от свързани променливи и функции могат да бъдат поставени в обобщена единица, наречена клас. Ако променливите имат определени стойности, класът се превръща в обект. Обектът обаче не се създава само чрез присвояване на стойности на променливата. Класът е инстанциран, за да получи обект; и всеки създаден обект има свое собствено име, различно от другите обекти от същия клас. Следващата програма показва клас, наречен TheCla и обект, наречен obj; той също така показва как обектът е създаден и използван във функцията main ():
#includeизползване на пространство от имена std;
клас TheCla
публично:
int num;
void func (char cha, const char * str)
Cout << "There are " << num << " books worth " << cha << str << " in the store." << '\n';
;
int main ()
TheCla obj;
обект.num = 12;
обект.func ('$', "500");
връщане 0;
Резултатът е:
В магазина има 12 книги на стойност 500 долара.
Забележете, че за да присвоите стойността 12 на променливата num, обектът трябва да бъде създаден, преди да може да се извърши присвояването. Възможно е програмистът да присвои стойността, без да създава (създава) обект. За да се постигне това, променливата num трябва да бъде декларирана като статична. Тогава той ще бъде достъпен като “TheCla :: num” без името на обекта, но с името на класа. Следващата програма илюстрира това:
#includeизползване на пространство от имена std;
клас TheCla
публично:
статично const int num = 12;
void func (char cha, const char * str)
Cout << "There are " << num << " books worth " << cha << str << " in the store." << '\n';
;
int main ()
Cout << TheCla::num << '\n';
TheCla obj;
обект.func ('$', "500");
връщане 0;
Резултатът е:
12
В магазина има 12 книги на стойност 500 долара.
Имайте предвид, че за да получите достъп до члена на данните, num в main (), трябва да се използва операторът за разделителна способност, ::. Също така не че променливата, num трябва да бъде направена постоянна и инициализирана в описанието на класа (дефиниция).
Функция на статичния член
Забележете, че в предишния списък на програмата по-горе, за да се използва функцията func в main (), трябва да бъде създаден екземпляр на обект. Възможно е програмистът да извика функцията, без да създава екземпляр (създава) обект. За да се постигне това, дефиницията на функцията трябва да бъде предшествана с думата „статичен“. Тогава той ще бъде достъпен като “TheCla :: func ()” без името на обекта, но с името на класа. Следващата програма илюстрира това за статични членове на данни и статични членове:
#includeизползване на пространство от имена std;
клас TheCla
публично:
статично const int num = 12;
static void func (char cha, const char * str)
Cout << "There are " << num << " books worth " << cha << str << " in the store." << '\n';
;
int main ()
TheCla :: func ('$', "500");
връщане 0;
Резултатът е:
В магазина има 12 книги на стойност 500 долара.
Продължителност на съхранението на нишката
Нишката като функция в C ++, все още не е внедрена от компилатора на g ++. Така че, вместо да се обясни това, цитатът от спецификацията C ++ се дава, както следва:
- Всички променливи, декларирани с ключовата дума thread_local, имат продължителност на съхранение на нишките. Съхранението за тези обекти ще продължи за времето на нишката, в която са създадени. Има отделен обект или препратка за нишка и използването на декларираното име се отнася до обекта, свързан с текущата нишка.
- Променлива с продължителност на съхранение на нишките трябва да бъде инициализирана преди първото ѝ поддържане и ако е конструирана, ще бъде унищожена при излизане на нишката.”
Заключение
Животът на даден обект започва, когато инициализацията му приключи, и приключва, когато се освободи съхранението му. Продължителността на динамичното съхранение започва, когато съхранението, създадено от (нов тип) се инициализира, и приключва, когато обектът излезе извън обхвата или бъде изтрит чрез „изтриване на указател“. Продължителността на статичен обект започва, когато обектът е инициализиран, и завършва в края на програмата. След като статичният обект е инициализиран, първоначалната му стойност не може да бъде променена, дори ако дефиницията му е преоценена. Членовете на статични данни и статичните членове на функцията са достъпни извън описанието на класа с “ClassName :: name”.
Chrys
