#include <cstdlib>
#include <iostream>

using namespace std;

int main(int argc, char *argv[])
{
int a=7; //Dichiarazione variabile intera con inizializzazione
int *p = 0; //Dichiarazione puntatore ad intero
p = new int; //Allocazione di memoria per l'intero
p=&a;

cout<<*p<<"n"; //Stampa il valore contenuto nella variabile puntata
cout<<p<<"n"; //Stampa il contenuto del puntatore, cioè l'indirizzo della variabile puntata
cout<<&p<<"n"; //Stampa l'indirizzo del puntatore

cout<<a<<"n"; //Stampa il contenuto del variabile a
cout<<&a<<"n"; //Stampa l'indirizzo della variabile a

delete p; // rilascia l'area di memoria

system("PAUSE");
return EXIT_SUCCESS;
}

A differenza dal C, il C++ consente l'esistenza di più funzioni con lo stesso nome, che sono chiamate: "funzioni sovrapposte" dette anche “funzioni di overload”. Il compilatore distingue una funzione dall'altra in base alla lista degli argomenti: due funzioni con overload devono differire per il numero e/o per il tipo dei loro argomenti.

Es. funz( ); funz(int a);

verranno chiamate con lo stesso nome funz, ma sono in realtà due funzioni diverse, in quanto non ha nessun argomento mentre la seconda ha un argomento int.

Non sono ammesse funzioni con overload che differiscano solo per il tipo del valore di ritorno ; né sono ammesse funzioni che differiscano solo per argomenti di default.

Es. void funz(int); e int funz(int);

non sono accettate, in quanto generano ambiguità: infatti, in una chiamata tipo funz(n), il programma non saprebbe se trasferirsi alla prima oppure alla seconda funzione (non dimentichiamo che il valore di ritorno può non essere utilizzato).

Es. funz(int); e funz(int, double=0.0);

non sono accettate, in quanto generano ambiguità: infatti, in una chiamata tipo funz(n), il programma non saprebbe se trasferirsi alla prima funzione (che ha un solo argomento), oppure alla seconda (che ha due argomenti, ma il secondo può essere omesso per default).
La tecnica dell'overload é molto usata in C++, perché permette di programmare in modo semplice ed efficiente: funzioni che eseguono operazioni concettualmente simili possono essere chiamate con lo stesso nome, anche se lavorano su dati diversi.

La programmazione orientata agli oggetti (OOP, Object Oriented Programming) è uno stile fondamentale di programmazione, che prevede di raggruppare in un'unica entità, detta classe, sia le strutture dati che le procedure che operano su di esse, creando per l'appunto un oggetto.
Come nel mondo reale la realizzazione di un oggetto avviene in più fasi, lo stesso è nella programmazione ad oggetti.

Fase di costruzione di un oggetto:



Progetto
Nel mondo della programmazione ad oggetti (OOP) il progetto altro non è che la classe, cioè un’entità logica, non occupa spazio in memoria, che definisce variabili, funzioni e altri oggetti che possono essere pubblici, privati o protetti.

Costruttori
La vita di un oggetto classe ha inizio nel momento in cui viene creato, ossia viene allocato spazio nella memoria per contenere i dati dell’oggetto.

A questo punto sorge spontaneo la domanda:
“Ma da chi viene creato?”
“Dal costruttore.”

Il costruttore è una funzione il cui nome è il nome della classe: il costruttore viene chiamato automaticamente quando viene creato un oggetto appartenente alla stessa classe.

Sintassi:
nome_classe ( );

Oggetto

“L’oggetto è un’istanza della classe”.

L’oggetto è un’entità fisica, che occupa spazio in memoria, realizzata dalla classe (progetto) che combina elementi dati, funzioni e altri oggetti.
Questi elementi, detti anche modificatori, possono essere pubblici, privati e protetti.
Gli elementi pubblici costituiscono l’interfaccia cioè l’insieme delle variabili e funzioni a nostra disposizione per interagire con l’oggetto.
Gli elementi privati costituiscono tutta quella parte di codice a cui noi non abbiamo accesso perché il loro stato garantisce il corretto funzionamento dell’oggetto, “una sorta di protezione per impedire all’utente di combinare danni”.

Distruttore
Il distruttore è l’opposto del costruttore cioè quando termina il tempo di vita di un oggetto questo viene eliminato dal distruttore, per liberare la memoria occupata dai campi dati dell’oggetto.
Il distruttore è anch’essa una funzione che ha lo stesso nome della classe ma è preceduto dal simbolo ‘~’ (tilde).

Sintassi:
~ nome_classe ( );


Come si dichiara un oggetto in C++:

class tipo {
public:
tipo var1;
tipo var2;
tipo var3;
funzione membro 1;
funzione membro 2;

protected:
tipo var4;
tipo var5;
tipo var6;
funzione membro 3;
funzione membro 4;

private:
tipo var7;
tipo var8;
tipo var9;
funzione membro 5;
funzione membro 6;
} oggetto;

Esempio pratico:

class Rettangolo {
public:
//attributi
float base , altezza;
//metodi
float Area ( ) {
return base*altezza;
}; // Fine Area
} Figura1; // Fine classe

In questo esempio la classe Rettangolo si compone di due attributi di tipo reale e di un metodo che restituisce un numero reale ottenuto moltiplicando i due attributi.

figura1.base = 12 ;
figura1.altezza = 8 ;
cout << “L’area del rettangolo è “ <<figura1.Area ( ) << endl ;

Con questo esempio potete notare che è l’oggetto ad essere utilizzato tramite l’annotazione puntata e non il progetto. Quindi il progetto è un modello,un idea, un prototipo che ci serve per la dichiarazione degli attributi e dei metodi. Mentre l’oggetto, che è fisico, reale, ha un corpo, è colui che andremo ad utilizzare per svolgere determinate azioni.