Клас за съхранение в C ++ определя живота и видимостта на променливата / функциите. Животът е продължителността, до която променливата остава активна, а видимостта е достъпността на променлива от различни модули на програмата. Това помага да се проследи съществуването на определена променлива по време на изпълнение на програмата. В този блог за класове за съхранение ще разгледаме различни класове за съхранение, използвани в C ++.
Нека да започнем.
Какво е клас на съхранение в C ++?
Всяка променлива в C ++ има тип данни и клас на съхранение. Типът данни указва типа данни, които могат да се съхраняват в променлива като int, float, char и т.н. Класът за съхранение контролира две различни свойства на променлива: продължителност и обхват.
Бихте виждали, че всяка променлива има тип данни, но досега може да не сте виждали нито един клас за съхранение, прикрепен към променлива. Всъщност, ако не дефинирате клас за съхранение, компилаторът автоматично му присвоява клас за съхранение по подразбиране. Класът за съхранение на променлива дава информация за мястото на съхранение на променливата в паметта, първоначалната стойност по подразбиране, обхвата на променливата и нейния живот.
Видове клас на съхранение
В C ++ програма има пет класа за съхранение:
- Автоматичен
- регистрирам
- статични
- външен
- променлив
Нека обсъдим подробно всеки един от класовете за съхранение.
Клас за автоматично съхранение
Класът за автоматично (автоматично) съхранение е класът за съхранение по подразбиране за всички локални променливи, които са декларирани във функция или блок. Ключовата дума auto се използва рядко, докато пишете a Програма C ++ .
Обхватът на автоматичните променливи е във функцията или блока, където са декларирани и не може да бъде достъпен извън тази функция или блок. Той може да бъде достъпен и в рамките на вложени блокове в родителския блок / функция, в който е декларирана автоматичната променлива.
Можете да получите достъп до автоматичните променливи извън техния обхват, като използвате променлива на указателя. Трябва да посочите същото място в паметта, където се намират променливите.
Неговият живот е същият като живота на функцията. След като изпълнението на функция приключи, променливата се унищожава.
По подразбиране им се присвоява стойност на боклука, докато се декларира.
Синтаксис:
тип данни var_name1 [= стойност]
или
автоматично тип данни var_name1 [= стойност]
В горния пример са дефинирани две променливи с един и същ клас на съхранение. Auto може да се използва само за дефиниране на локални променливи, т.е.в рамките на функции.
Регистрирайте клас за съхранение
Както подсказва името, класът за съхранение на регистъра се използва за деклариране на променливи на регистъра. Всички функционализиране на регистърната променлива е същата като автоматичната променлива, с изключение на това, че компилаторът се опитва да съхранява тези променливи в регистъра на микропроцесора, ако е наличен безплатен регистър. Ако няма наличен безплатен регистър, те се съхраняват само в паметта.
По този начин операциите с регистърни променливи са много по-бързи от тези на други променливи, които се съхраняват в паметта по време на изпълнение на програмата.
Като цяло, няколко променливи, които трябва да бъдат достъпни често в дадена програма, се декларират в класа за съхранение на регистъра, за да се подобри времето за работа на програмата. Адресът на регистърна променлива не може да бъде получен с помощта на указатели.
Максималният размер на променливата е равен на размера на регистъра (т.е. приблизително една дума). Не може да има приложен унарен оператор ‘&’, тъй като няма място в паметта.
Синтаксис:
регистър тип данни var_name1 [= стойност]
Пример:
как да конвертирате двойно в int java -
{регистрирайте int pi}Дефинирането на „регистър“ не означава, че променливата ще се съхранява в регистър. Може да се съхранява в регистър в зависимост от хардуера и ограниченията за изпълнение.
Нека разгледаме пример за класове за регистрация и автоматично съхранение.
Пример:
#include using space names std // деклариране на променливата, която трябва да се направи extern // инициална стойност може също да бъде инициализирана в x int x void autoStorageClass () {printf ('nDemonstrating auto classnn') // деклариране на автоматична променлива (просто // пише и 'int a = 32') int num = 32 // отпечатва автоматичната променлива 'a' printf ('Стойност на променливата' num '' 'декларирана като автоматично:% dn', num) printf ( '--------------------------------')} void registerStorageClass () {printf ('nДемонстриращ регистър classnn') / / деклариране на регистърна променлива регистър char c = 'G' // отпечатване на регистърната променлива 'b' printf ('Стойност на променливата' c '' ', декларирана като регистър:% dn', c) printf ('---- ---------------------------- ')} int main () {// За демонстрация на автоматичен клас за съхранение autoStorageClass () // За демонстрация регистър Клас на съхранение registerStorageClass () връщане 0}Изход:
Клас на статично съхранение
Класът на статичното съхранение се използва за деклариране статични променливи . Статичните променливи запазват стойността си (т.е. последната стойност), дори когато са извън обхвата си. Статичните променливи се инициализират само веднъж &съществуват до прекратяването на програмата.
Паметта се разпределя само веднъж към статичната променлива и не се разпределя нова памет, тъй като те не са повторно декларирани. Глобалните статични променливи могат да бъдат достъпни навсякъде в програмата. По подразбиране им се присвоява стойността 0 от компилатора.
В C ++, когато static се използва за член на данни от клас, той причинява само едно копие на този член да бъде споделено от всички обекти от неговия клас.
Синтаксис:
статичен тип данни var_name1 [= стойност]
Пример:
#include void function (void) static int c = 5 // Глобална статична променлива main () {while (c--) {function ()} return 0} void function (void) {static int cnt = 2 cnt ++ std :: Cout<< 'cnt is ' << cnt std::cout << ' and c is ' << c << std::endl } Изход:
Клас за външно съхранение
Класът за външно съхранение се изисква, когато променливите трябва да се споделят в множество файлове. Външните променливи имат глобален обхват и тези променливи са видими извън файла, в който са декларирани. Външната променлива е видима за всички програми. Използва се, ако два или повече файла споделят една и съща променлива или функция.
Животът на външните променливи е толкова дълъг, колкото е прекратена програмата, в която са декларирани. Нормална глобална променлива може да се направи и extern, като се постави ключовата дума ‘extern’ преди нейното деклариране / дефиниция във всяка функция / блок.
Когато използвате ‘extern’, променливата не може да бъде инициализирана, тъй като всичко, което прави, е да насочи името на променливата към място за съхранение, което е предварително дефинирано.
Синтаксис
външен тип данни var_name1
Пример
#include int cnt extern void write_extern () main () {cnt = 5 write_extern ()}Втори файл: support.cpp
#include extern int cnt void write_extern (void) {std :: cout<< 'Count is ' << cnt << std::endl } Тук ключовата дума extern се използва за деклариране на cnt в друг файл. Сега компилирайте тези два файла, както следва & минус
$ g ++ main.cpp support.cpp -o запис
Това ще създаде изпълнима програма за запис, опитайте се да изпълните запис и проверете резултата, както следва & минус
$. / пиши
как да компилирам Java програма
5
Продължавайки напред с класа за съхранение в C ++, нека да разгледаме последния, т.е., Променлив клас за съхранение.
Променлив клас за съхранение
Изменяемият спецификатор се прилага само за обекти на класа, което позволява на член на обект да замени функцията const member. Тоест, изменяем член може да бъде модифициран от функция на const член.
Най-накрая, нека разгледаме таблицата за сравнение, за да разберем разликите между различните класове за съхранение.
Клас на съхранение | Ключова дума | Живот | Видимост | Начална стойност |
Автоматично | Автоматичен | Функционален блок | Местен | Боклук |
Външен | външен | Цяла програма | Глобален учене ssis стъпка по стъпка | Нула |
Статично | статични | Цяла програма | Местен | Нула |
Регистрирам | регистрирам | Функционален блок | Местен | Боклук |
Променлив | променлив | Клас | Местен | Боклук |
След като преминете през горните програми на C ++, бихте разбрали какви са различните класове за съхранение в C ++ и как да ги внедрите. Надявам се, че този блог е информативен и с добавена стойност за вас.
По този начин стигнахме до края на тази статия за „Класове за съхранение в C ++“.
Ако искате да научите повече, разгледайте от Edureka, доверена компания за онлайн обучение. Курсът за обучение и сертифициране на Java J2EE и SOA на Edureka е предназначен да ви обучи както за основните, така и за разширените Java концепции, заедно с различни Java рамки като Hibernate & Spring.
Имате въпрос към нас? Моля, споменете го в раздела за коментари на този блог и ние ще се свържем с вас възможно най-скоро.