Šajā rakstā ir aprakstītas dažādas funkcijas const atslēgvārds kas ir atrodams C++ tiek apspriesti. Ikreiz, kad const atslēgvārds ir pievienots ar jebkuru metodi (), mainīgo, rādītāja mainīgais , un ar klases objektu tas novērš šo konkrēto objekts/metode()/mainīgais lai mainītu tā datu vienumu vērtību.

Pastāvīgie mainīgie:

Pastāv noteikts noteikumu kopums konstanto mainīgo deklarēšanai un inicializācijai:

• The const mainīgais uzdevuma veikšanas laikā nevar atstāt inicializētu.
• Tam nevar piešķirt vērtību nekur programmā.
• Pastāvīgajam mainīgajam bija jānorāda skaidra vērtība nemainīgā mainīgā deklarēšanas laikā.

Zemāk ir C++ programma, lai parādītu iepriekš minēto koncepciju:

lauva salīdzinājumā ar tīģeri

// 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>

Kļūda kļūdainas deklarācijas gadījumā : Ja mēģināt inicializēt mainīgo const, nepiešķirot skaidru vērtību, tiek ģenerēta kompilēšanas laika kļūda (CTE).

Const atslēgvārds ar rādītāja mainīgajiem:

Rādītājus var deklarēt ar const atslēgvārdu. Tātad ir trīs iespējamie veidi, kā izmantot atslēgvārdu const ar rādītāju, un tie ir šādi:

Kad rādītāja mainīgais norāda uz const vērtību :

Sintakse:

  const data_type* var_name;>

Zemāk ir C++ programma, lai īstenotu iepriekš minēto koncepciju:

// 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>

Paskaidrojums: Iepriekš minētajā gadījumā i un j ir divi rādītāja mainīgie, kas norāda uz atmiņas vietu const int-type un char-type, taču šajās atbilstošajās vietās saglabāto vērtību var mainīt, kā mēs to darījām iepriekš.

Citādi , uz parādīsies šāda kļūda: Ja mēģinām modificēt mainīgā const vērtību.

Kad const rādītāja mainīgais norāda uz vērtību :

Sintakse:

  data_type* const     var_name;>

Tālāk ir sniegts piemērs, lai parādītu iepriekš minēto koncepciju:

jquery ar klikšķi

// 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>

Paskaidrojums: Vērtības, kas tiek saglabātas atbilstošajā rādītāja mainīgajā i un j, ir maināmas, bet vietas, uz kurām norāda konstrādītāja mainīgie, kur tiek glabātas atbilstošās x un y vērtības, nav maināmas.

Pretējā gadījumā tiks parādīta šāda kļūda: Rādītāja mainīgie ir const un norāda uz vietām, kur tiek saglabāti x un y, ja mēģināsim mainīt adreses atrašanās vietu, tad mēs saskarsimies ar kļūdu.

Kad const rādītājs norāda uz const mainīgo :

Sintakse:

  const data_type* const var_name;>

Zemāk ir C++ programma, lai parādītu iepriekš minēto koncepciju:

// 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>

Paskaidrojums: Šeit const rādītāja mainīgais norāda uz mainīgo const. Tātad jums nav atļauts mainīt konst rādītāja mainīgais (*P) ne arī vērtību, kas saglabāta ar to norādītajā vietā rādītāja mainīgais (*P).

Pretējā gadījumā tiks parādīta šāda kļūda: Šeit gan rādītāja mainīgais, gan atrašanās vietas, uz kurām norāda rādītāja mainīgais, ir nemainīgas, tāpēc, ja kāds no tiem tiek mainīts, tiks parādīta šāda kļūda:

Nododiet const-argumenta vērtību funkcijas parametram, kas nav const, izraisa kļūdu : Argumenta const vērtības nodošana funkcijas parametram, kas nav const, nav derīgs, tas rada kompilēšanas laika kļūdu.

Zemāk ir C++ programma, lai parādītu iepriekš minēto koncepciju:

// 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; }>

Izvade: Kompilēšanas laika kļūda, kas parādīsies tā, it kā const vērtība tiktu nodota jebkuram funkcijas argumentam, kas nav const, tad parādīsies šāda kompilēšanas laika kļūda:

np vidējais

Turklāt const rādītāja nodošana neradīs kļūdu, jo tiek izveidots cits rādītājs, kas arī norāda uz to pašu atmiņas vietu.

//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>

Kods tiek izpildīts bez kļūdām, un abiem rādītājiem ir dažādas adreses.

Īsumā iepriekš minēto diskusiju var noslēgt šādi:

1. int vērtība = 5; // nekonstanta vērtība

2. const int *ptr_1 = &value; // ptr_1 norāda uz const int vērtību, tāpēc tas ir rādītājs uz const vērtību.

3. int *const ptr_2 = &value; // ptr_2 norāda uz int, tāpēc tas ir const rādītājs uz vērtību, kas nav konst.

4. const int *const ptr_3 = &value; // ptr_3 norāda uz const int vērtību, tāpēc šis ir const rādītājs uz const vērtību.

Pastāvīgas metodes:

Tāpat kā biedru funkcijas un dalībnieku funkciju argumentus, klases objektus var arī deklarēt kā konst . Objektu, kas deklarēts kā const, nevar modificēt, un tādējādi tas var izsaukt tikai const dalībnieku funkcijas, jo šīs funkcijas nodrošina, ka objekts netiek mainīts.

Sintakse:

const Class_Name Object_name;>

• Kad funkcija ir deklarēta kā const, to var izsaukt jebkura veida objektos, const objektos, kā arī objektos, kas nav const.
• Ikreiz, kad objekts tiek deklarēts kā const, tas ir jāinicializē deklarēšanas laikā. Taču objekta inicializācija deklarēšanas laikā iespējama tikai ar konstruktoru palīdzību.

Ir divi veidi, kā a pastāvīga funkcija deklarācija:

Parastā konst-funkcijas deklarācija :

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

Klases locekļa funkcija :

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

Zemāk ir konstantas funkcijas piemērs:

// 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>

Ja mēģināsit izsaukt funkciju bez const no const objekta, tiks parādīta šāda kļūda

Pastāvīgie funkciju parametri un atgriešanas veids :

Funkcijas() parametri un Funkcijas () atgriešanas veidu var deklarēt kā nemainīgu. Pastāvīgās vērtības nevar mainīt, jo jebkurš šāds mēģinājums radīs kompilēšanas laika kļūdu.

Zemāk ir C++ programma, lai īstenotu iepriekš minēto pieeju:

Java pamata valoda

// 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>

Paskaidrojums: Ja funkcijā foo () tiek izmantots priekšraksts y = 6, tiks parādīta šāda kļūda:

• // y = 6; const vērtību nevar mainīt vai modificēt.

Pastāvīgajam atgriešanas veidam : Funkcijas () atgriešanas veids ir const, un tāpēc tā mums atgriež const vesela skaitļa vērtību. Zemāk ir C++ programma, lai īstenotu iepriekš minēto pieeju:

// 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>

Atgrieztā vērtība būs nemainīga vērtība.

Nav arī būtiskas problēmas, lai funkcijai nodotu mainīgo const vai neconst, ja vien mēs to nododam pēc vērtības, jo tiek izveidota jauna kopija. Problēma rodas, mēģinot nodot konstanto mainīgo, atsaucoties uz funkciju, kuras parametrs nav nemainīgs. Tas neņem vērā const kvalifikatoru, kas rada šādu kļūdu:

Const atgriešanas veidam un const parametram : Šeit gan atgriešanas veids, gan funkcijas parametrs ir const tipa. Zemāk ir C++ programma, lai īstenotu iepriekš minēto pieeju:

// 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>

Paskaidrojums: Šeit gan const, gan neconst vērtības var nodot funkcijai kā const parametru, taču mēs nedrīkstam pēc tam mainīt nodotā ​​mainīgā vērtību, jo parametrs ir const. Pretējā gadījumā mēs saskarsimies ar tālāk norādīto kļūdu.

// y=9; tas parādīs kompilēšanas laika kļūdu, jo y ir const var, tā vērtību nevar mainīt.