const

1. const #define DIMENSIUNE 1000 const int DIMENSIUNE = 1000; • Utilizarea valorilor constante este importantă, de exemplu, în declararea tablourilor de date. De exemplu, se poate face declaraţia: double vector[DIMENSIUNE]; • Se poate folosi const pentru toate tipurile predefinite de date (char, int, float şi double) şi pentru cele derivate din acestea. • Notă: Datorită bug-urilor greu de depistat ce pot fi introduse de utilizarea directivei #define, se recomandă folosirea în locul lor de variabile const.

2. const const int i = 10; // declaraţie specifica pentru o constanta const int j = i + 10; // valoare preluata dintr-o expresie constanta char buf[ j + 10 ]; // se foloseşte o expresieconstanta int main() { cout << "Introdu un caracter: "; const char c1 = cin.get(); const char c2 = c1 + 2; cout << c2 << endl; return 0; } • Este recomandat ca dacă valoarea iniţială a unei variabile nu se modifică pe parcursul execuţiei programului, aceasta să fie declarată const, prin aceasta obţinându-se protejarea acestei, dar i se permite şi compilatorului să obţină un cod mai eficient eliminându-se stocări şi citiri de memorie inutile.

3. const • int main() • { • const a[] = {1,2,3,4}; • //float vect1[a[2]]; // (1) Ilegal ! • struct S {int i, j; }; • const S s[] = { {1,2} , {3,4} }; • //float vect2[s[1].i]; // (2) Ilegal ! • cout << "Introdu un caracter: "; • const char c = cin.get(); • //float vect3[c]; // (3) Ilegal ! • return 0; • }

4. const • Pointer la const const int* p; int const* p1; • Cele două declaraţii sunt similare. Atât p, cât şi p1 sunt variabile pointer ordinare care pot pointa spre valori const int. int main() { const int a = 10; int b; const int* p1; int* p2; p1 = &a; // OK ! // *p1 = 20; // Ilegal, se încearcă modificarea unui obiect const p1 = &b; // OK ! // *p1 = 20; // Ilegal, deşi b nu este const, prin p1 el este protejat // p2 = &a; // Ilegal, pointer la int preia adresa unui const int p2 = &b; // OK ! *p2 = 20; // OK ! p2 este pointer ordinar, deci * p2 poate fi lvalue return 0; }

5. const Pointer const int a = 1; int* const p = &a; p este un pointer const, ceea ce înseamnă că el nu-şi va putea modifica valoarea. În schimb, obiectul către care pointează nu este const, deci poate fi modificat. int main() { const int a = 10; int b; const int* const p1 = &a; // p1 = &b; // se încearcă modificarea adresei din p1 care insa este un const int* const p2 = &b; // *p1 = 20; // Ilegal, se încearcă modificarea unui obiect const *p2 = 20; return 0; }

6. const Parametri de funcţii şi valori returnate - Transfer prin valoare const void f1(const int a) { a++; // instrucţiune ilegală – eroare semnalată la compilare }  //… int var = 10; f1(var); //…  a este variabilă locală funcţiei şi preia prin copiere valoarea variabilei var. a este declarat const, nu var. Dacă se doreşte înlăturarea oricărei confuzii, se poate realiza declararea argumentului ca un const în interiorul funcţiei, în loc de declararea în lista de parametric, prin declararea unei referinţe la argument:  void f2(int a) { const int& r = a; r++; // instrucţiune ilegală – eroare semnalată la compilare }

7. const Transfer de valori prin adrese void t(int * ) {} void u( const int * cip) { // *cip =2 ; // se încearcă modificarea unui const int i = *cip; // int * ip2 = cip ; // atribuire între pointeri de tipuri diferite // (int* - const int*) } const char * v() { return "rezultatul funcţiei v()";// se returnează adresa unui şir de caractere // static } const int * const w() { static int i; return &i ; }

8. const int main() { int x = 0; int* ip = &x; const int* cip = &x; t(ip); // OK! // ! t(cip); u(ip); // OK! u(cip); // ! char* cp = v(); const char* ccp = v(); // OK! // ! int* ip2 = w(); const int* const ccip = w(); // OK! // ! *w() = 1; return 0; }

9. const Class X {}; X f() { return X() ; } void g1(X&) { } void g2 (const X&) { } int main() { // ! g1( f() ); // funcţia preia un obiect temporar care este in mod implicit // const, deci nu corespunde tipul g2( f() ); return 0; }

10. const class X {}; X f() { return X() ; } void g1(X&) { } void g2 (const X&) { } int main() { // ! g1( f() ); // funcţia preia un obiect temporar care este in mod implicit // const, deci nu corespunde tipul g2( f() ); return 0; }

11. const const în clase class X { const int size; public: X (int sz); void print (); }; X::X(int sz) : size(sz) {} void X::print() {cout<< size <<endl;} int main() { X a(1), b(2), c(3); a.print(), b.print(), c.print(); return 0; }

12. const class X { const int size = 100; // Illegal int array[size]; // Illegal //... };

13. const • Înţelesul unui const aflat în interiorul clasei este : „ Această valoare const aparţine numai acestui obiect, nu întregii clase.” • O soluţie de a introduce constante în interiorul clasei este folosirea enumerărilor (enum). class X { enum { size = 100 }; int i[size]; };

14. const Obiecte const şifuncţii membre Un obiect const este declarat similar pentru obiecte de tipuri predefinite şi pentru cele definite de utilizator. De exemplu: const int a = 1; const X b(2);

15. const class X { int i; public: X(int ii); int f() const; int g() ; int h() const; }; X::X(int ii) : i(ii) {} int X::f() const { return i; } int X::g() { return i; } // int X::h() const { return ++i; } // Ilegal ! se încearcă //modificarea unei date // membre într-o funcţie const

16. const int main() { X x1(10); const X x2(20); x1.f(); x2.f(); x1.g(); // x2.g(); // Ilegal ! apel de funcţie non-const // pentru un obiect const return 0; }

17. const mutable  O modalitate de modificare a unor membri ai obiectelor const este folosirea cuvântului cheie mutable în declaraţia clasei, acesta specificând tocmai că un membru dată poate fi modificat în interiorul unui obiect const: class X { int i; mutable int j; public: X(); void f() const; }; X::X(){ i = 0; } void X::f() const { // i++; j++; // OK! - e declarate mutable }