PROGRAMMZIONE AD OGGETTI 2001-2001

9-1-2002

COSTANTI

In C++ ci sono due modi per definire una costante:

#define MAX 100
const int MAX = 100;

La differenza tra i due modi non è trascurabile:

usando la direttiva #define, si fa una sorta di macro: infatti il preprocessore (che esegue le inclusioni dei file header nel codice ed esegue tutte le altre direttive precedute da #) non fa altro che sostituire alla scrittura MAX la scrittura 100; in questo modo MAX diventa una costante globale, valida in ogni punto del programma.

usando invece la parola chiave const si dichiara una variabile che, una volta inizializzata, non può più essere modificata in alcun modo; una costante definita in questo modo può essere anche locale. Attenzione: una costante definita con la chiave const deve sempre essere inizailizzata al momento della dichiarazione.

Forse il vantaggio maggiore dell'utilizzo della parola chiave const è quello di poter inizializzare la costante anche durante l'esecuzione del programma (runtime):

int x;
cin >> x;

const int MIN = x;

/*la costante MIN viene inizializzata runtime. In seguito non può più essere modificata*/

	vedi esempio safeconst.cpp

 

HOME

PUNTATORI COSTANTI

C'è differenza nel definire un puntatore costante e un puntatore ad una costante.

const int* punt;

Con questa istruzione si dichiara un puntatore punt che può essere inizializzato con l'indirizzo di una costante. Ad esempio:

punt = &MIN;

Perciò il valore del puntatore può cambiare; è possibile scrivere:

punt = &MAX;

Quello che non può cambiare è il contenuto della cella di memoria puntata dal puntatore; non è possibile scrivere:

*punt = 3;  /* il compilatore dà errore */

E' possibile anche definire un puntatore costante (in pratica una variabile):

int* const punt2 = &x;

In questo caso è possibile modificare il valore di x tramite il puntatore ma non è possibile fare una cosa di questo tipo:

int y = 10;
punt2 = &y;  /* il compilatore dà errore */

	vedi esempio constpointers.cpp

HOME

COSTANTI E FUNZIONI

E' possibile definire una costante all'interno di una funzione nel seguente modo:

int f(const int x);
...
int a;
a = f(a);

dove x è una costante che ha validità all'interno della funzione f e il cui valore è quello della variabile a e non può essere cambiato. Attenzione: non si rende costante il valore di a ma solamente il valore di x, che è diversa da a.

Nel passaggio per riferimento non si fa altro che definire un puntatore costante:

int g(int& y);
...
int b;
b = g(b);

y non è altro che un puntatore costante alla zona di memoria corrispondente a b; è una variabile la cui zona di memoria è la stessa della variabile b: cambiando y si cambia anche b.

Il passaggio parametri by reference è stato trattato anche nella lezione 4-12-2001

Si può anche definire una funzione di questo tipo:

int h(const int& z);
...
a = h(b);
a = h(MAX);

z è una variabile che non può essere modificata ed è associata alla stessa zona di memoria della variabile o della costante passate alla funzione (in questo caso b o MAX). Questo passaggio parametri è utile se non si vuole modificare il valore di una variabile passata ad una funzione by reference: il valore di z (e quindi il valore di b) non può essere modificato all'interno della funzione h. Non è possibile passare ad una funzione come g una costante come MAX: sarebbe come creare una variabile (y) che ha la stessa zona di memoria della costante passata alla funzione (MAX) e quindi permettere alla g di modificare MAX attraverso y.

HOME

COSTANTI E CLASSI

E' possibile definire una costante all'interno di una classe. Ci sono due modi per inizializzare la costante: il primo è il seguente:

class X
{

const int MAX;
public:

X(int max);
...

}

X::X(int max) : MAX(max){...} /* costruttore */

In questo modo, ogni volta che viene creato un nuovo oggetto la costante MAX di questo oggetto viene inizializzata con il valore passato al costruttore. Così ogni oggetto contiene una costante potenzialmente diversa. Attenzione: la costante può essere inizializzata solo usando l'operatore ":" e non all'interno del costruttore. Scrivere "MAX(max)" equivale a scrivere "MAX = max;"; questo vale anche per le variabili e non solo per le costanti.

E' possibile inizializzare la costante anche in un altro modo:

class Y
{

const int MIN = 1;
...

}

In questo modo tutti gli oggetti di classe Y avranno al loro interno la variabile MIN inizializzata ad 1. Usando la sintassi:

static const int MIN = 1;

MIN stavolta è un unica costante in comune a tutti gli oggetti.

E' possibile creare degli oggetti costanti:

const NOMECLASSE a(1,2);

L'oggetto a viene inizializzato dal costruttore e poi non può più essere modificato. Il compilatore non permette allora di utilizzare i normali metodi dell'oggetto ma solo quelli definiti nel seguente modo:

int f() const; /* dichiarazione nel file header */
...
int NOMECLASSE :: f(...) const{...} /* definizione */

Così il compilatore (in fase di compilazione) controlla il metodo f in modo da assicurarsi che non venga modificato il valore dei dati dell'oggetto (se questo non è vero dà un errore). Perciò i soli metodi che possono essere utilizzati sull'oggetto costante sono quelli definiti come const. Tutti gli altri metodi non possono essere utilizzati.

HOME

FUNZIONI INLINE

Le macro possono essere usate per sostituire nel codice anche pezzi molto lunghi: per questo sono molto rischiose e da usare con cautela.

Si possono però definire delle funzioni inline che vengono eseguite dal compilatore solamente nel punto in cui sono chiamate:

inline int f() {return (2);}

Se le funzioni sono troppo grandi però vengono trattate come funzioni normali.

Se un metodo viene definito nella dichiarazione della classe (cioè nell'header file), questo metodo viene identificato dal compilatore come una funzione inline.

HOME