Niestabilny C++

Niestabilny C

„Twórcy aplikacji w przestrzeni użytkownika powinni zawsze odwoływać się do odpowiednich podręczników kompilatorów, aby dowiedzieć się, jak kwalifikator może być obsługiwany w różnych kontekstach, ponieważ niestabilne zachowanie słów kluczowych powinno być zwykle postrzegane jako zależne od sprzętu. Gdy obiekt jest oznaczony jako ulotny, kompilator często jest informowany, że nigdy nie powinien być optymalizowany pod kątem operacji ładowania i zawsze powinien być pobierany z pamięci podstawowej, a nie z rejestrów lub pamięci podręcznych. Jednak gdy kompilator próbuje umieścić lokalizację pamięci w rejestrze, jest ona automatycznie buforowana, mimo że istnieje wiele warstw pamięci podręcznych, które są w dużej mierze niedostępne dla oprogramowania i utrzymywane tylko na sprzęcie. W rezultacie dostęp do pamięci RAM można uzyskać wielokrotnie szybciej z linii pamięci podręcznej w pobliżu procesora niż z identycznej lokalizacji pamięci.

Problemy mogą wystąpić, jeśli nie użyjemy niestabilnego kwalifikatora, który po włączeniu optymalizacji powoduje, że kod może nie działać zgodnie z oczekiwaniami. Gdy przerwania są wykorzystywane i włączone, kod nie może działać zgodnie z planem. Dane są przechowywane tylko w pamięci ulotnej, gdy zasilanie jest włączone. Po usunięciu zapasu następuje utrata danych.

Jednak nieulotna pamięć masowa przechowuje dane nawet po wyłączeniu zasilania. Informacje procesowe są przez krótki czas przechowywane w pamięci ulotnej, ponieważ jest znacznie szybsze niż w pamięci nieulotnej. W przeciwieństwie do pamięci nieulotnej, pamięć ulotna jest bardziej odpowiednia do ochrony poufnych danych. Dzieje się tak, ponieważ dane są niedostępne, gdy zasilanie jest wyłączone. Ulotna pamięć masowa kosztuje dużo, ponieważ systemy komputerowe mogą pomieścić od kilku do kilku GB”.







Właściwości kwalifikatora lotnego w C++

W tym miejscu zostanie zademonstrowany nietrwały kwalifikator języka C++. Kiedy deklarujemy zmienną, stosowany jest kwalifikator „volatile”. Służy jako przypomnienie dla kompilatora, że ​​wartość może się zmienić w dowolnym momencie. Lotne posiadają niektóre z cech wymienionych poniżej.



• Przypisania pamięci nie można zmienić za pomocą słowa kluczowego volatile.



• Zmienne rejestru nie mogą być buforowane.





• Jeśli chodzi o przypisanie, wartość nie może zostać zmieniona.

Użycie kwalifikatora Volatile w C++

1. Pomimo tego, że Twój kod nie modyfikuje wartości zmiennej, może to jednak zrobić. W rezultacie za każdym razem, gdy kompilator sprawdza stan zmiennej, nie może zakładać, że jest ona taka sama jak najnowsza odczytana z niej wartość lub najnowsza przechowywana wartość; raczej musi ponownie uzyskać wartość zmiennej.



2. Kompilator nie musi eliminować czynności przechowywania wartości, ponieważ jest to „efekt uboczny”, widoczny z zewnątrz i występujący, gdy wartość jest zapisana w zmiennej ulotnej. Na przykład, jeśli dwie wartości są umieszczone w wierszu, kompilator musi umieścić wartość dwukrotnie.

Składnia kwalifikatora Volatile w C++

# Zmienny typ danych nazwa_zmiennej

W deklaracji należy użyć słowa kluczowego volatile, a typ danych odnosi się do dowolnego typu danych, w tym double, float lub integer. Na koniec wybieramy nazwę zmiennej. Możemy zdefiniować zmienną ulotną za pomocą dowolnej z metod, ponieważ obie deklaracje są prawidłowe.

Przykład: kwalifikator lotny służy do identyfikowania obiektów, które mogą być modyfikowane przez inne wątki lub działania zewnętrzne w C++

Jeśli obiekt zostanie zmieniony przez zewnętrzny sygnał lub procedurę działającą jako przerwanie, zmienioną wartość należy pobrać z pamięci RAM, ponieważ w międzyczasie stan pamięci podręcznej nie jest już odpowiedni. W rezultacie kompilator odpowiednio obsługuje dostęp do obiektów ulotnych.

#include
#include
#include

używając std :: Cout ;
używając std :: koniec ;
używając std :: zły ;
używając std :: jedzenie ;

lotny int sekundy = 0 ;

próżnia Opóźnienie pięć sekund ( ) {
podczas gdy ( sekundy < 3 ) {
śpisz ( 200000 ) ;
zły << 'Czekanie...' << koniec ;
}
}

próżnia Przyrost sekund ( ) {
dla ( int i = 0 ; i < 5 ; ++ i ) {
spać ( 1 ) ;
zły << 'zwiększony' << koniec ;
sekundy = sekundy + 1 ;
}
}

int Główny ( ) {
struktura początek czasu { } ;
struktura koniec czasu { } ;
standardowe :: wątek wątek1 ;

wątek1 = standardowe :: wątek ( Przyrost sekund ) ;

Opóźnienie pięć sekund ( ) ;

wątek1. Przystąp ( ) ;
zwrócić EXIT_SUCCESS ;
}


Aby zilustrować potencjalny scenariusz, użyliśmy słowa kluczowego volatile, które ma zmienną zadeklarowaną jako Sekundy typu danych „int” i przypisaliśmy jej wartość 0. Następnie konstruujemy dwie funkcje: jedną jako „DelayFiveSeconds”, która zmienia globalną ulotną zmienną całkowitą, a drugą jako „IncrementSeconds”, która wykonuje tę samą ocenę wewnątrz pętli while. Należy zauważyć, że ten przykład pozwala na zapętlenie pętli while przez sekundy, gdy sekundy powinny być mniejsze niż 3.

Gdy warunek zostanie spełniony, zostanie wykonany blok while. Wewnątrz bloku while wywołaliśmy metodę unsleep, która wyświetla instrukcję „czekanie”. Funkcja „IncrementSceonds” ma pętlę for. Po iteracji wywoływana jest metoda sleep, która drukuje instrukcję „increment” i inkrementuje zmienną „seconds”. Wstępne wykonanie funkcji „IncrementSeconds” odbywa się przez osobny wątek utworzony przez funkcję main. Metoda „DelayFiveSeconds” jest następnie wywoływana przez główny wątek, wprowadzając pętlę, która nie zakończy się, jeśli zmienna sekund nie przekroczy wartości 5.

Jak tylko główny wątek zauważy, że wartość zmiennej sekund uległa zmianie, wróci z metody, ponieważ inny wątek już zaczął ją współbieżnie zwiększać.

Aby uruchomić kod wątku w C++, powinniśmy użyć polecenia „g++ -pthread –o nazwapliku nazwapliku.cc”. Jeśli nie wdrożysz „-pthread” w poleceniu, istnieje szansa, że ​​kompilator wyrzuci wyjątek. W rezultacie skutecznie stworzyliśmy funkcję warunkowego oczekiwania, która czeka, aż ulotny obiekt zostanie zmieniony przez siłę zewnętrzną. Należy pamiętać, że blok kodu aktualizacji może pochodzić z innej sekcji tłumaczenia lub działania sygnału zewnętrznego, nawet jeśli ten kod nadal będzie działał tak samo, jeśli kwalifikator volatile zostanie usunięty i zostanie użyta konwencjonalna zmienna globalna.

Wniosek

W tym miejscu omówimy omówienie lotności w C++ wraz ze składnią, użyciem i odpowiednimi przykładami, aby lepiej zrozumieć. Ponieważ kompilator nie może przewidzieć wartości, niestabilność ma kluczowe znaczenie w programowaniu w C. Podstawową korzyścią z używania zmiennej jest to, że jej wartość może się zmieniać za każdym razem, gdy użytkownik zażąda jej modyfikacji lub gdy inny wątek wykorzystujący tę samą zmienną jest aktywny.