Проблемите могат да възникнат, ако не използваме непостоянен квалификатор, който включва, когато оптимизацията е активирана, кодът може да не функционира според очакванията. Когато прекъсванията се използват и разрешават, кодът не може да функционира по план. Данните се запазват само в енергонезависимо хранилище, докато захранването е включено. Когато захранването бъде премахнато, се случва загуба на данни.
Енергонезависимото хранилище обаче запазва данните дори ако токът спре. Информацията за процеса се съхранява за кратко в енергонезависимо хранилище, тъй като е значително по-бързо от енергонезависимото хранилище. За разлика от енергонезависимото съхранение, променливото хранилище е по-подходящо за защита на чувствителни данни. Това е така, защото данните са недостъпни, когато захранването е изключено. Летливото хранилище струва много, защото компютърните системи могат да поемат само няколко MB до няколко GB от него.
Свойства на квалификатора Volatile в C++
Тук ще бъдат демонстрирани средствата на C++ volatile qualifier. Когато декларираме променлива, се прилага квалификаторът „volatile“. Той служи като напомняне на компилатора, че стойността може да се променя по всяко време. Летливите притежават някои от чертите, изброени по-долу.
• Присвояването на паметта не може да се промени с ключовата дума volatile.
• Променливите на регистъра не могат да бъдат кеширани.
• По отношение на присвояването стойността не може да бъде променяна.
Използване на квалификатора Volatile в C++
1. Въпреки че вашият код не променя стойността на променливата, той все пак може да го направи. В резултат на това всеки път, когато компилаторът проверява състоянието на променливата, той не може да приеме, че тя е същата като най-скорошната прочетена от нея стойност или най-скорошната съхранена стойност; по-скоро трябва да придобие отново стойността на променливата.
2. Компилаторът не е длъжен да елиминира акта на съхраняване на стойност, тъй като това е „страничен ефект“, който може да се види отвън и се появява, когато стойността се записва в променлива променлива. Например, ако две стойности са поставени в ред, компилаторът трябва да постави стойността два пъти.
Синтаксис на квалификатора volatile в C++
# Променлив_тип данни_име_на променливаКлючовата дума volatile трябва да се използва в декларацията, а типът данни се отнася за всеки тип данни, включително double, float или integer. Накрая избираме име за променливата. Можем да дефинираме променлива променлива с помощта на един от методите, тъй като и двете декларации са валидни.
Пример: Квалификаторът Volatile се използва за идентифициране на обекти, които могат да бъдат модифицирани от други нишки или външни действия в C++
Ако обектът е променен от външен сигнал или процедура, която действа като прекъсване, променената стойност трябва да бъде извлечена от RAM, тъй като междувременно кешираното състояние вече не е подходящо. В резултат на това компилаторът обработва достъпа до непостоянни обекти по подходящ начин.
#include#include
#include <нишка>
използвайки стандартно :: cout ;
използвайки стандартно :: endl ;
използвайки стандартно :: cerr ;
използвайки стандартно :: храня се ;
летлив вътр секунди = 0 ;
невалиден Забавяне пет секунди ( ) {
докато ( секунди < 3 ) {
заспивам ( 200 000 ) ;
cerr << 'очакване...' << endl ;
}
}
невалиден Увеличаване на секунди ( ) {
за ( вътр аз = 0 ; аз < 5 ; ++ аз ) {
сън ( 1 ) ;
cerr << 'увеличен' << endl ;
секунди = секунди + 1 ;
}
}
вътр основен ( ) {
структура начало на времето { } ;
структура край на времето { } ;
std :: резба нишка1 ;
нишка1 = std :: резба ( Увеличаване на секунди ) ;
Забавяне пет секунди ( ) ;
нишка1. присъединяване ( ) ;
връщане EXIT_SUCCESS ;
}
За да илюстрираме потенциалния сценарий, използвахме ключовата дума volatile, която има променлива, декларирана като секунди от тип данни „int“ и й присвоиха стойност 0. След това конструираме две функции: една като „DelayFiveSeconds“, която променя глобалната променлива променлива с цяло число, и друга като „IncrementSeconds“, която извършва същата оценка вътре в цикъла while. Трябва да се отбележи, че този пример позволява цикълът while да премине през секундите, когато секундите трябва да са по-малко от 3.
Когато условието е изпълнено, блокът while ще бъде изпълнен. Вътре в блока while ние извикахме метода unsleep, който отпечатва оператора „чака“. Функцията “IncrementSceonds” има for цикъл. След итерацията се извиква методът на заспиване, който отпечатва оператора „increment“ и увеличава променливата „seconds“. Първоначалното изпълнение на функцията “IncrementSeconds” се извършва от отделна нишка, създадена от основната функция. След това методът „DelayFiveSeconds“ се извиква от основната нишка, влизайки в цикъл, който няма да приключи, ако променливата секунди не се премести над стойността от 5.
Веднага щом основната нишка забележи, че стойността на променливата seconds се е променила, тя ще се върне от метода, защото друга нишка вече е започнала да я увеличава едновременно.
За да стартираме кода на нишката в C++, трябва да използваме командата “g++ -pthread –o име на файл име на файл.cc”. Ако не внедрите „-pthread“ в командата, има вероятност компилаторът да хвърли изключение. В резултат на това ние ефективно направихме условна функция за изчакване, която изчаква, докато непостоянният обект бъде променен от външна сила. Важно е да имате предвид, че кодовият блок за актуализация може да дойде от различна секция за транслация или външно сигнално действие, въпреки че този код ще продължи да функционира по същия начин, ако квалификаторът volatile бъде премахнат и се използва конвенционална глобална променлива.
Заключение
Тук разглеждаме общ преглед на Volatile в C++ заедно със синтаксиса, употребата и подходящи примери за по-добро разбиране. Тъй като компилаторът не може да предвиди стойността, volatile е от решаващо значение при програмирането на C. Основното предимство от използването на volatile е, че стойността му може да варира всеки път, когато потребител поиска да бъде модифицирана или когато е активна друга нишка, използваща същата променлива.