W tym artykule omówiono różne funkcje pliku słowo kluczowe stałe w którym się znajduje C++ są omawiane. Zawsze, gdy słowo kluczowe stałe jest dołączony do dowolnej metody (), zmiennej, zmienna wskaźnikowa , a z obiektem klasy zapobiega temu konkretnemu obiekt/metoda()/zmienna aby zmodyfikować wartość jego elementów danych.

Stałe zmienne:

Istnieje pewien zestaw reguł dotyczących deklaracji i inicjalizacji zmiennych stałych:

• The zmienna stała nie może pozostać niezainicjowany w momencie przydzielania zadania.
• Nie można mu przypisać wartości w żadnym miejscu programu.
• Należy podać jawną wartość zmiennej stałej w momencie deklaracji zmiennej stałej.

Poniżej znajduje się program C++ demonstrujący powyższą koncepcję:

// C++ program to demonstrate the // the above concept #include  using namespace std; // Driver Code int main() {  // const int x; CTE error  // x = 9; CTE error  const int y = 10;  cout << y;  return 0; }>

10>

Wystąpił błąd związany z błędną deklaracją : Jeśli spróbujesz zainicjować zmienną const bez przypisania jawnej wartości, zostanie wygenerowany błąd w czasie kompilacji (CTE).

węzeł listy w Javie

Słowo kluczowe Const ze zmiennymi wskaźnikowymi:

Wskaźniki można deklarować za pomocą słowa kluczowego const. Istnieją zatem trzy możliwe sposoby użycia słowa kluczowego const ze wskaźnikiem:

Kiedy Zmienna wskaźnikowa wskazuje na wartość stałą :

Składnia:

  const data_type* var_name;>

Poniżej znajduje się program C++ realizujący powyższą koncepcję:

// C++ program to demonstrate the // above concept #include  using namespace std; // Driver Code int main() {  int x{ 10 };  char y{ 'M' };  const int* i = &x;  const char* j = &y;  // Value of x and y can be altered,  // they are not constant variables  x = 9;  y = 'A';  // Change of constant values because,  // i and j are pointing to const-int  // & const-char type value  // *i = 6;  // *j = 7;  cout << *i << ' ' << *j; }>

9 A>

Wyjaśnienie: W powyższym przypadku i oraz j są dwiema zmiennymi wskaźnikowymi wskazującymi lokalizację w pamięci const typu int i typu char, ale wartość przechowywana w tych odpowiednich lokalizacjach może zostać zmieniona, jak zrobiliśmy powyżej.

W przeciwnym razie , the pojawi się następujący błąd: Jeśli spróbujemy zmodyfikować wartość zmiennej const.

hashtable kontra hashmap

Gdy zmienna wskaźnikowa const wskazuje wartość :

Składnia:

  data_type* const     var_name;>

Poniżej znajduje się przykład ilustrujący powyższą koncepcję:

// C++ program to demonstrate the // above concept #include  using namespace std; // Driver Code int main() {  // x and z non-const var  int x = 5;  int z = 6;  // y and p non-const var  char y = 'A';  char p = 'C';  // const pointer(i) pointing  // to the var x's location  int* const i = &x;  // const pointer(j) pointing  // to the var y's location  char* const j = &y;  // The values that is stored at the memory location can  // modified even if we modify it through the pointer  // itself No CTE error  *i = 10;  *j = 'D';  // CTE because pointer variable  // is const type so the address  // pointed by the pointer variables  // can't be changed  // i = &z;  // j = &p;  cout << *i << ' and ' << *j << endl;  cout << i << ' and ' << j;  return 0; }>

10 and D 0x7ffe21db72b4 and D>

Wyjaśnienie: Wartości przechowywane w odpowiednich zmiennych wskaźnikowych i oraz j można modyfikować, ale lokalizacje wskazywane przez zmienne wskaźnikowe o stałym wskaźniku, w których przechowywane są odpowiednie wartości x i y, nie podlegają modyfikacji.

W przeciwnym razie pojawi się następujący błąd: Zmienne wskaźnikowe są stałe i wskazują lokalizacje, w których przechowywane są x i y. Jeśli spróbujemy zmienić lokalizację adresu, napotkamy błąd.

Gdy wskaźnik const wskazuje na zmienną const :

Składnia:

  const data_type* const var_name;>

Poniżej znajduje się program C++ demonstrujący powyższą koncepcję:

// C++ program to demonstrate // the above concept #include  using namespace std; // Driver code int main() {  int x{ 9 };  const int* const i = &x;  // *i=10;  // The above statement will give CTE  // Once Ptr(*i) value is  // assigned, later it can't  // be modified(Error)  char y{ 'A' };  const char* const j = &y;  // *j='B';  // The above statement will give CTE  // Once Ptr(*j) value is  // assigned, later it can't  // be modified(Error)  cout << *i << ' and ' << *j;  return 0; }>

9 and A>

Wyjaśnienie: Tutaj zmienna wskaźnikowa const wskazuje na zmienną const. Zatem nie wolno Ci zmieniać const zmienna wskaźnikowa(*P) ani wartość przechowywana we wskazanym przez nią miejscu zmienna wskaźnikowa (*P).

W przeciwnym razie pojawi się następujący błąd: Tutaj zarówno zmienna wskaźnikowa, jak i lokalizacje wskazywane przez zmienną wskaźnikową są stałe, więc jeśli którakolwiek z nich zostanie zmodyfikowana, pojawi się następujący błąd:

czcionka gimp

Przekaż wartość argumentu stałego do parametru innego niż stały funkcji powodującej błąd : Przekazanie wartości argumentu const do parametru funkcji innego niż const jest nieprawidłowe i powoduje błąd kompilacji.

Poniżej znajduje się program C++ demonstrujący powyższą koncepcję:

// C++ program to demonstrate // the above concept #include  using namespace std; int foo(int* y) { return *y; } // Driver code int main() {  int z = 8;  const int* x = &z;  cout << foo(x);  return 0; }>

Wyjście: Błąd w czasie kompilacji, który pojawi się, gdy wartość const zostanie przekazana do dowolnego argumentu funkcji innego niż const, pojawi się następujący błąd w czasie kompilacji:

Dodatkowo przekazanie wskaźnika const nie spowoduje żadnego błędu, ponieważ tworzony jest inny wskaźnik, który również wskazuje na tę samą lokalizację pamięci.

//C++ program to demonstrate the above concept #include  using namespace std; void printfunc(int* ptr) {  cout << 'Value :' << *ptr << endl;  cout << 'Address of ptr :' << &ptr << endl; } //Driver Code int main() {  int x = 10;  int* const i = &x;  printfunc(i);  cout << 'Address of i :' << &i << endl; }>

Value :10 Address of ptr :0x7ffff0189b48 Address of i :0x7ffff0189b70>

Kod jest wykonywany bez błędów, a oba wskaźniki mają różne adresy.

W skrócie powyższą dyskusję można zakończyć następująco:

1. wartość int = 5; // wartość inna niż stała

2. const int *ptr_1 = &wartość; // ptr_1 wskazuje na stałą wartość int, więc jest to wskaźnik na wartość stałą.

3. int *const ptr_2 = &wartość; // ptr_2 wskazuje na int, więc jest to stały wskaźnik na wartość inną niż stała.

4. const int *const ptr_3 = &wartość; // ptr_3 wskazuje na stałą wartość int, więc jest to stały wskaźnik na wartość stałą.

Metody stałe:

Podobnie jak funkcje składowe i argumenty funkcji składowych, obiekty klasy można również zadeklarować jako konst . Obiekt zadeklarowany jako const nie może być modyfikowany i dlatego może wywoływać tylko funkcje składowe const, ponieważ te funkcje zapewniają, że obiekt nie będzie modyfikowany.

Składnia:

pamięć wirtualna

const Class_Name Object_name;>

• Gdy funkcja jest zadeklarowana jako const, można ją wywołać na obiekcie dowolnego typu, obiekcie const, a także obiektach innych niż const.
• Ilekroć obiekt jest deklarowany jako const, musi zostać zainicjowany w momencie deklaracji. Jednak inicjalizacja obiektu podczas deklaracji jest możliwa tylko przy pomocy konstruktorów.

Istnieją dwa sposoby: a stała funkcja deklaracja:

Zwykła deklaracja funkcji stałej :

  const void foo()    {     //void foo() const Not valid    }          int main()    {     foo();    }>

Stała funkcja członkowska klasy :

  class    {     void foo() const     {     //.....     }    }>

Poniżej znajduje się przykład funkcji stałej:

// C++ program to demonstrate the // constant function #include  using namespace std; // Class Test class Test {  int value; public:  // Constructor  Test(int v = 0) { value = v; }  // We get compiler error if we  // add a line like 'value = 100;'  // in this function.  int getValue() const { return value; }  // a nonconst function trying to modify value  void setValue(int val) { value = val; } }; // Driver Code int main() {  // Object of the class T  Test t(20);  // non-const object invoking const function, no error  cout << t.getValue() << endl;  // const object  const Test t_const(10);  // const object invoking const function, no error  cout << t_const.getValue() << endl;  // const object invoking non-const function, CTE  // t_const.setValue(15);  // non-const object invoking non-const function, no  // error  t.setValue(12);  cout << t.getValue() << endl;  return 0; }>

20 10 12>

Jeśli spróbujesz wywołać funkcję inną niż const z obiektu const, wystąpi następujący błąd

Stałe parametry funkcji i typ zwracany :

Parametry funkcji () i Typ zwracany przez funkcję () można zadeklarować jako stały. Wartości stałych nie można zmienić, ponieważ każda taka próba wygeneruje błąd w czasie kompilacji.

Poniżej znajduje się program C++ realizujący powyższe podejście:

// C++ program to demonstrate the // above approach #include  using namespace std; // Function foo() with variable // const int void foo(const int y) {  // y = 6; const value  // can't be change  cout << y; } // Function foo() with variable int void foo1(int y) {  // Non-const value can be change  y = 5;  cout << '
' << y; } // Driver Code int main() {  int x = 9;  const int z = 10;  foo(z);  foo1(x);  return 0; }>

10 5>

Wyjaśnienie: Jeśli w funkcji foo() zostanie użyta instrukcja y = 6, wyświetli się następujący błąd:

• // y = 6; wartości stałej nie można zmienić ani zmodyfikować.

wyrównywanie obrazów w CSS

Dla stałego typu zwrotu : Typ zwracany przez funkcję () to const, dlatego zwraca nam stałą wartość całkowitą. Poniżej znajduje się program C++ realizujący powyższe podejście:

// C++ program for the above approach #include  using namespace std; const int foo(int y) {  y--;  return y; } int main() {  int x = 9;  const int z = 10;  cout << foo(x) << '
' << foo(z);  return 0; }>

8 9>

Zwracana wartość będzie wartością stałą.

Ponadto nie ma istotnego problemu z przekazywaniem zmiennej stałej lub zmiennej innej niż stała do funkcji, o ile przekazujemy ją według wartości, ponieważ tworzona jest nowa kopia. Problem pojawia się, gdy próbujemy przekazać stałą zmienną przez odwołanie do funkcji, której parametr nie jest stały. Pomija to kwalifikator const, co prowadzi do następującego błędu:

Dla typu zwracanego const i parametru const : W tym przypadku zarówno typ zwracany, jak i parametr funkcji są typu stałego. Poniżej znajduje się program C++ realizujący powyższe podejście:

// C++ program for the above approach #include  using namespace std; const int foo(const int y) {  // y = 9; it'll give CTE error as  // y is const var its value can't  // be change  return y; } // Driver code int main() {  int x = 9;  const int z = 10;  cout << foo(x) << '
' << foo(z);  return 0; }>

9 10>

Wyjaśnienie: W tym przypadku zarówno wartości stałe, jak i inne niż const mogą być przekazywane do funkcji jako parametr const, ale nie wolno nam wówczas zmieniać wartości przekazywanej zmiennej, ponieważ parametrem jest const. W przeciwnym razie napotkamy błąd jak poniżej:

// y=9; zwróci błąd kompilacji, ponieważ y jest stałą var, której wartości nie można zmienić.