Tässä artikkelissa eri toiminnot const avainsana joka löytyy C++ keskustellaan. Milloin tahansa const avainsana on liitetty millä tahansa menetelmällä (), muuttujalla, osoittimen muuttuja , ja luokan objektin kanssa se estää sen objekti/metodi()/muuttuja muuttaaksesi sen tietokohteiden arvoa.

Vakiomuuttujat:

Vakiomuuttujien ilmoittamiselle ja alustamiselle on tietty joukko sääntöjä:

• The const muuttuja ei voi jättää alustamatta toimeksiannon aikana.
• Sille ei voi antaa arvoa missään ohjelmassa.
• Vakiomuuttujalle oli annettava eksplisiittinen arvo vakiomuuttujan ilmoittamishetkellä.

Alla on C++-ohjelma, joka osoittaa yllä olevan konseptin:

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

Virhe virheellisessä ilmoituksessa : Jos yrität alustaa const-muuttujan antamatta nimenomaista arvoa, syntyy käännösaikavirhe (CTE).

Const-avainsana osoitinmuuttujilla:

Osoittimet voidaan ilmoittaa const-avainsanalla. On siis kolme mahdollista tapaa käyttää const-avainsanaa osoittimen kanssa, jotka ovat seuraavat:

Kun osoitinmuuttuja osoittaa const-arvoon :

teollisuus ja tehdas

Syntaksi:

  const data_type* var_name;>

Alla on C++-ohjelma yllä olevan konseptin toteuttamiseksi:

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

Selitys: Tässä yllä olevassa tapauksessa i ja j ovat kaksi osoitinmuuttujaa, jotka osoittavat muistipaikkaan const int-type ja char-type, mutta näihin vastaaviin paikkoihin tallennettua arvoa voidaan muuttaa kuten olemme tehneet edellä.

Muuten , the seuraava virhe tulee näkyviin: Jos yritämme muokata const-muuttujan arvoa.

Kun const-osoittimen muuttuja osoittaa arvoon :

Syntaksi:

  data_type* const     var_name;>

Alla on esimerkki yllä olevan käsitteen havainnollistamiseksi:

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

Selitys: Vastaaviin osoitinmuuttujiin i ja j tallennetut arvot ovat muokattavissa, mutta const-osoittimen muuttujien osoittamat paikat, joihin x:n ja y:n vastaavat arvot on tallennettu, eivät ole muokattavissa.

Muussa tapauksessa näyttöön tulee seuraava virheilmoitus: Osoitinmuuttujat ovat const ja osoittavat paikkoihin, joihin x ja y on tallennettu, jos yritämme muuttaa osoitteen sijaintia, kohtaamme virheen.

Kun const-osoitin osoittaa const-muuttujaan :

loop bashille

Syntaksi:

  const data_type* const var_name;>

Alla on C++-ohjelma, joka osoittaa yllä olevan konseptin:

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

Selitys: Tässä const-osoittimen muuttuja osoittaa const-muuttujaan. Joten et saa myöskään muuttaa kokoonpanoa osoitinmuuttuja (*P) eikä sen osoittamaan paikkaan tallennettu arvo osoitinmuuttuja(*P).

Muussa tapauksessa näyttöön tulee seuraava virheilmoitus: Tässä sekä osoitinmuuttuja että osoitinmuuttujan osoittamat paikat ovat vakioita, joten jos jotakin niistä muutetaan, tulee seuraava virheilmoitus:

Const-argumentin arvon välitys funktion ei-const-parametrille aiheuttaa virheen : Const-argumentin arvon välittäminen funktion ei-const-parametrille ei kelpaa, se antaa käännösaikavirheen.

Alla on C++-ohjelma, joka osoittaa yllä olevan konseptin:

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

Lähtö: Käännösaikavirhe, joka näkyy ikään kuin const-arvo välitettäisiin funktion mille tahansa ei-const-argumentille, niin seuraava käännösaikavirhe tulee näkyviin:

Lisäksi const-osoittimen ohittaminen ei aiheuta virhettä, koska luodaan toinen osoitin, joka myös osoittaa samaan muistipaikkaan.

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

Koodi suoritetaan ilman virheitä ja kahdella osoittimella on eri osoitteet.

Pähkinänkuoressa yllä oleva keskustelu voidaan päätellä seuraavasti:

1. int arvo = 5; // ei-vakioarvo

2. const int *ptr_1 = &arvo; // ptr_1 osoittaa const int -arvoon, joten tämä on osoitin const-arvoon.

3. int *const ptr_2 = &arvo; // ptr_2 osoittaa int-arvoon, joten tämä on const-osoitin ei-const-arvoon.

4. const int *const ptr_3 = &arvo; // ptr_3 osoittaa const int -arvoon, joten tämä on const-osoitin const-arvoon.

Jatkuvat menetelmät:

Kuten jäsenfunktiot ja jäsenfunktion argumentit, luokan objektit voidaan myös ilmoittaa konst . Const:ksi ilmoitettua objektia ei voi muokata, joten se voi kutsua vain const-jäsentoimintoja, koska nämä toiminnot varmistavat, että objektia ei muokata.

kuinka vanha pete davidson on

Syntaksi:

const Class_Name Object_name;>

• Kun funktio on ilmoitettu const, sitä voidaan kutsua minkä tahansa tyyppiselle objektille, const-objektille sekä ei-const-objekteille.
• Aina kun objekti on ilmoitettu const, se on alustettava ilmoitushetkellä. Objektin alustus ilmoittamisen aikana on kuitenkin mahdollista vain konstruktorien avulla.

On kaksi tapaa a jatkuva toiminto ilmoitus:

Tavallinen const-funktion ilmoitus :

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

Luokan const-jäsenfunktio :

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

Alla on esimerkki vakiofunktiosta:

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

Seuraava virhe ilmenee, jos yrität kutsua non-const-funktiota const-objektista

Vakiofunktion parametrit ja palautustyyppi :

Funktio()-parametrit ja funktion() paluutyyppi voidaan ilmoittaa vakioksi. Vakioarvoja ei voi muuttaa, koska jokainen tällainen yritys aiheuttaa käännösaikavirheen.

Alla on C++-ohjelma yllä olevan lähestymistavan toteuttamiseksi:

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

Selitys: Seuraava virhe näytetään, jos lausetta y = 6 käytetään funktiossa foo():

• // y = 6; const-arvoa ei voi muuttaa tai muokata.

Vakiopalautustyypille : Funktion() palautustyyppi on const, joten se palauttaa meille const kokonaislukuarvon. Alla on C++-ohjelma yllä olevan lähestymistavan toteuttamiseksi:

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

Palautettava arvo on vakioarvo.

mikä on aakkosnumero

Const- tai ei-const-muuttujan välittäminen funktiolle ei myöskään ole olennaista, kunhan välitämme sen arvon mukaan, koska uusi kopio luodaan. Ongelma syntyy, kun yritämme välittää vakiomuuttujan viittaamalla funktioon, jonka parametri ei ole vakio. Tämä jättää huomiotta const-määritteen, joka johtaa seuraavaan virheeseen:

Const-palautustyypille ja const-parametrille : Tässä sekä palautustyyppi että funktion parametri ovat const-tyyppisiä. Alla on C++-ohjelma yllä olevan lähestymistavan toteuttamiseksi:

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

Selitys: Tässä sekä const- että ei-const-arvot voidaan välittää const-parametrina funktiolle, mutta emme saa muuttaa välitetyn muuttujan arvoa, koska parametri on const. Muussa tapauksessa kohtaamme seuraavanlaisen virheen:

// y = 9; se antaa käännösaikavirheen, koska y on const var, sen arvoa ei voi muuttaa.