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

constPointer 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

constParametri 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

constTransfer 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

constconst î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 şi funcţ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

constclass 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

constmutable  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

}