Kwalifikatory C ++ i specyfikatory klasy przechowywania

CV oznacza stał. Deklaracja obiektu, która nie jest poprzedzona stałą i/lub lotną, jest typem bezkwalifikowanym CV. Z drugiej strony deklaracja obiektu poprzedzona stałą i/lub lotną jest typem kwalifikowanym przez CV. Jeśli obiekt jest zadeklarowany, stał się, wartości w jego lokalizacji nie można zmienić. Zmienna lotna jest zmienną, której wartość jest pod wpływem programisty, a zatem nie może być zmieniana przez kompilator.Specyfikatory klas przechowywania odnoszą się do życia, miejsca i sposobu, w jaki istnieje typ. Specyfikatory klas przechowywania są statyczne, zmienne, Thread_Local i Extern.

W tym artykule wyjaśniono kwalifikatory C ++ i specyfikatory klas przechowywania. Zatem pewna wstępna wiedza w C ++ przydaje się, aby naprawdę docenić ten artykuł.

Treść artykułu:

• Kwalifikatory
• Specyfikatory klasy przechowywania
• Wniosek

Kwalifikacje:

const

Obiekt zadeklarowany stała jest obiektem przechowywania (lokalizacji), którego wartości nie można zmienić. Na przykład w stwierdzeniu:

int const theint = 5;

Wartości 5 w pamięci masowej dla tegot nie można zmienić.

lotny

Rozważ następujące stwierdzenie:

int portval = 26904873;

Kompilatory czasami zakłócają wartość zmiennej z nadzieją na zoptymalizowanie programu. Kompilator może utrzymać wartość zmiennej jako stałej, gdy nie powinna być stała. Wartości obiektów, które mają związek z mapowanymi pamięcią porty IO lub procedurami usługi przerywania urządzeń peryferyjnych, mogą być zakłócone przez kompilator. Aby zapobiec takim zakłóceniu, spraw, aby zmienna zmienna, na przykład:

Int lotny portval;
Portval = 26904873;
lub jak:
int zmienny portval = 26904873;

Łączenie stałej i niestabilnej:

Const i niestabilne mogą wystąpić w jednym stwierdzeniu w następujący sposób:

int const lotny portu = 26904873;

CV-kwalifikatory

Zmienna poprzedzona const i/lub lotną jest typ kwalifikowanym przez CV. Zmienna nie poprzedzona ani stałą, albo oba lub oba to typ bezkwalifikowany przez CV.

Zamawianie:

Jeden typ może być bardziej kwalifikowany CV niż inny:

• Żaden kwalifikator CV nie jest mniejszy niż kwalifikator const
• Żaden kwalifikator CV nie jest również niższy niż niestabilny kwalifikator
• Żaden kwalifikator CV nie jest mniejszy niż kwalifikator wolny
• kwalifikator const jest mniejszy niż kwalifikator ogółu
• niestabilny kwalifikator jest mniejszy niż kwalifikator ogółu

Nie zostało jeszcze zakończone, jeśli const i niestabilne są tej samej rangi.

Tablica i instanowany obiekt:

Gdy tablica jest zadeklarowana stała, jak w poniższym stwierdzeniu, oznacza to, że nie można zmienić wartości każdego elementu tablicy:

const char arr [] = „a”, „b”, „c”, 'd';

Niezależnie od tego, czy jest to „A”, „B”, „C”, czy „D”, nadal nie można go zmienić na inną wartość (charakter).

Podobna sytuacja dotyczy inferencji. Rozważ następujący program:

#włączać
za pomocą przestrzeni nazw Std;
CLA CLA

publiczny:
char cH0 = „a”;
char cH1 = „b”;
char cH2 = „c”;
char cH3 = „d”;
;
int main ()

const cla obj;
powrót 0;

Z powodu stwierdzenia „const cla obj;” Z funkcją Main (), ani „A”, ani „B”, ani „C”, ani „D” nie mogą zostać zmienione na inną wartość.

Specyfikatory klasy przechowywania:

Specyfikatory klas przechowywania są statyczne, zmienne, Thread_Local i Extern.

Specyfikator klasy statycznej

Specyfikator klasy statycznej przechowywania umożliwia przeżycie zmiennej po przejściu jej zakresu, ale nie można uzyskać do niego dostępu bezpośrednio.

Poniższy program ilustruje to z funkcją rekurencyjną:

#włączać
za pomocą przestrzeni nazw Std;
int funct ()

static int Stac = 10;
Cout << stac < 50)

Cout << '\n';
powrót 0;

funct ();

int main ()

funct ();
powrót 0;

Wyjście to:

10 20 30 40 50

Jeśli zmienna statyczna nie jest inicjowana przy pierwszej deklaracji, przyjmuje wartość domyślną dla jej typu.

Specyfikator statyczny może być również używany z członkami klasy; Zastosowanie tutaj jest inne. Tutaj umożliwia dostęp do członka bez instancji obiektu.

Poniższy program ilustruje to dla członka danych:

#włączać
za pomocą przestrzeni nazw Std;
CLA CLA

publiczny:
Static const int num = 8;
;
int main ()

Cout << Cla::num << '\n';
powrót 0;

Wyjście to:

8

Statyczny element danych musi być stały. Należy zauważyć, że użycie operatora rozdzielczości zakresu w celu uzyskania dostępu do zmiennej statycznej poza jej zakresem (w głównej funkcji).

Poniższy program ilustruje użycie „statycznego” dla funkcji członka:

#włączać
za pomocą przestrzeni nazw Std;
CLA CLA

publiczny:
Statyczna metoda void ()

Cout << "Of static member function!" << '\n';

;
int main ()

CLA :: Method ();
powrót 0;

Wyjście to:

Statycznej funkcji członka!

Należy zauważyć, że użycie operatora rozdzielczości zakresu w celu uzyskania dostępu do funkcji elementu statycznego poza jej zakresem (w funkcji głównej).

Zmieniony specyfikator

Pamiętaj, że z góry, że jeśli instanowany obiekt rozpocznie się od Const, wartość dowolnego z jego normalnych elementów danych nie może zostać zmieniona. I aby każdy taki element danych został zmieniony, należy je zadeklarować, zmienne.

Poniższy program ilustruje to:

#włączać
za pomocą przestrzeni nazw Std;
CLA CLA

publiczny:
char cH0 = „a”;
char cH1 = „b”;
Zmieniony Char CH2 = „C”;
char cH3 = „d”;
;
int main ()

const cla obj;
obj.CH2 = „Z”;
Cout << obj.ch0 << " << obj.ch1 << " << obj.ch2 << " << obj.ch3 << " << '\n';
powrót 0;

Wyjście to:

„A„ B ”Z” D '

Specyfikator Thread_Local

W normalnym uruchomieniu programu wykonuje się jeden segment kodu, a następnie następny segment kodu, a następnie kolejny segment kodu. To jest jeden wątek; główny wątek. Jeśli dwa segmenty kodu wykonają jednocześnie (ten sam czas trwania), potrzebny jest drugi wątek. Wynik drugiego wątku może być nawet gotowy przed głównym wątkiem.

Funkcja main () jest jak główny wątek. Program może mieć więcej niż dwa wątki dla takiego asynchronicznego zachowania.

Drugi wątek potrzebuje zakresu (zakresu blokowego) w celu obsługi. Zazwyczaj jest to zapewniane przez zakres funkcji, funkcja. Zmienna w zewnętrznym zakresie, który można zobaczyć w zakresie drugiego wątku.

Poniższy krótki program ilustruje użycie specyfikatora Thread_Local:

#włączać
#włączać
za pomocą przestrzeni nazw Std;
Thread_Local int inter = 1;
void Thread_Function ()

inter = inter + 1;
Cout << inter << "nd thread\n";

int main ()

wątek Thr (& Thread_Function); // thr zaczyna działać
Cout << inter << "st or main thread\n";
thr.dołączyć(); // główny wątek czeka na to, że wątek się skończy
powrót 0;

Wyjście to:

1. lub główny wątek
2. wątek

Zmienna, inter, poprzedzona przez Thread_Local, oznacza, że ​​internowanie ma osobną instancję w każdym wątku. I że można go zmodyfikować w różnych wątkach, aby mieć różne wartości. W tym programie przypisuje się wartość 1 w głównym wątku i modyfikowana do wartości, 2 w drugim wątku.

Wątek potrzebuje specjalnego obiektu w celu obsługi. W przypadku tego programu biblioteka zawarta przez „#Include” ma klasę o nazwie wątek, z którego obiekt Thr został utworzony. Konstruktor tego obiektu odwołuje się do funkcji wątku jako argument. Nazwa funkcji wątku w tym programie to Thread_Function ().

Funkcja członka Join () dla obiektu specjalnego, na jego zastosowanym stanowisku, sprawia, że ​​główny wątek czeka, aż drugi wątek zakończy wykonywanie, zanim będzie kontynuowana, w przeciwnym razie funkcja main () może wyjść bez (drugiego) wątku dał swój wynik.

Specyfikator zewnętrzny

Mówiąc prosto, dla deklaracji pamięć nie jest przydzielana dla zmiennej lub funkcji, podczas gdy dla definicji pamięć jest przydzielana. Zastrzeżone słowo zewnętrzne umożliwia deklarowanie zmiennej globalnej lub funkcji w jednym pliku, ale zdefiniowanym w innym. Takie pliki nazywane są jednostkami tłumaczeniowymi dla kompletnej aplikacji C ++.

Wpisz następujący program i zapisz go z nazwą pliku, Mainfile:

#włączać
za pomocą przestrzeni nazw Std;
int myint;
const char ch;
void myfn ();
int main ()

myfn ();
powrót 0;

Zmienna, myint, stała zmienna, CH i funkcja, myfn (), zostały zadeklarowane bez zdefiniowania.

Wpisz następujący program z definicjami i zapisz go za pomocą nazwy pliku, w innym pliku, w tym samym katalogu:

#włączać
za pomocą przestrzeni nazw Std;
int myint = 10;
const char ch = „c”;
void myfn ()

Cout << "myFn() says " << myInt << " and " << ch <<'\n';

Spróbuj skompilować aplikację na terminalu (wiersz polecenia DOS) za pomocą następującego polecenia i zauważ, że nie może ono kompilacji:

G ++ Mainfile.CPP INTERFILE.cpp -o kompletne.exe

Teraz poprzedzaj trzy deklaracje w Mainfile ze słowem „zewnętrznym”, w następujący sposób:

extern int myint;
extern const char ch;
zewnętrzny void myfn ();

Ponownie zapisz Mainfile. Skompiluj aplikację z:

G ++ Mainfile.CPP INTERFILE.cpp -o kompletne.exe

(W ten sposób oddzielne pliki dla tej samej aplikacji są kompilowane w C ++)

I powinien się skompilować. Teraz uruchom aplikację, zakończ.exe, a wyjście powinno być:

myfn () mówi 10 i c

Zauważ, że przy użyciu „zewnętrznego” zmienna stała może być zadeklarowana w jednym pliku, ale zdefiniowana w innym. W ramach deklaracji funkcji i definicji w różnych plikach użycie Extree jest opcjonalne.

Kiedy używać zewnętrznego? Używaj go, gdy nie masz plików nagłówka z globalnymi deklaracją.

„EXTRIC” jest również używany z deklaracji szablonów - patrz później.

Wniosek:

Zmienna poprzedzona const i/lub lotną jest typ kwalifikowanym przez CV. Zmienna, nie poprzedzona ani stałą, albo oba, jest typem niewidocznym CV.

Specyfikatory klas przechowywania są statyczne, zmienne, Thread_Local i Extern. Wpływają one na żywotność (czas trwania), miejsce i sposób zatrudnienia zmiennych w aplikacji.