C++: differenze tra le versioni

La dichiarazione delle costanti è identica a quella delle variabili eccetto che deve sempre essere specificato un valore e la dichiarazione inizia con '''const'''.

Esempio:

 

=== Costante di definizione ===

Si utilizza le direttive di definizione con il comando '''#define'''. Non bisogna specificare il tipo. Esempio:

Nelle direttive di definizione NON va specificato il punto e virgola alla fine della dichiarazione ed esse vanno poste all'inizio del file, prima di qualsiasi funzione o variabile.

 

Le inclusioni di file di sistema vanno effettuate anch'esse con le direttive di definizione attraverso il comando '''#include <nomefile>'''. Tutti i file che verranno inclusi in questo modo devono essere presenti nel sistema o è necessario passare al compilatore le directory di inclusione.

Esempio:

=== Inclusioni personali ===

Le inclusioni di file di sistema vanno effettuate anch'esse con le direttive di definizione attraverso il comando '''#include "nomefile"'''. Tutti i file che verranno inclusi in questo modo devono essere presenti nella cartella del file che le richiama.

Esempio:

 

== Hello World ==

#include <iostream> //Libreria di sistema che contiene "cout"

int main()

return 0; //Esco dalla funzione

} //fine programma

 

 

== Using e Namespace ==

Nell'esempio precedente è stata utilizzata la forma di inclusione "a file", cioè è stato chiamato direttamente il file iostream.h. Questo comporta il caricamento completo di tutto il file e delle sue funzioni (es: cout). Se volessimo ridurre la quantità di memoria occupata si può richiamare il file senza estensione, quindi:

#include <iostream>

In questo modo non è disponibile nessuna funzione del file (infatti se fate ''cout << "ciao";'' non funzionerà). È possibile scegliere le funzioni da utilizzare attraverso il costrutto:

std viene chiamato '''namespace'''. Nella quasi totalità dei compilatori il namespace di default è '''std'''. Se volessimo utilizzare invece tutte le funzioni (equivalente a ''#include <iostream.h>'') dovremmo scrivere:

che utilizza tutte le funzioni del namespace.

Esempio completo:

#include <iostream> //Libreria di sistema che contiene "cout"

using std::cout; //Attivo la funzione cout

return (0); //Esco dalla funzione

} //fine programma

 

== Programmazione ad oggetti ==

===Funzioni===

Le funzioni si possono considerare dei sottoprogrammi che vengono chiamati dallo script principale e svolgono una determinata azione. Una volta conclusa la loro operazione, l'esecuzione ritorna allo script principale. Una funzione si dichiara in questo modo:

<small>'''Ricorda:'''(Le [parentesi quadre] indicano che quello che ci sta dentro è opzionale)</small>

Il tipo resitutito è il tipo di variabile che la funzione dovrà restituire. L'identificatore è il nome della funzione e gli argomenti sono le variabile che lo script principale passa alla funzione. Nelle '''{}''' viene contenuto il codice.

 

Ecco un esempio completo.

#include <iostream> //Libreria di sistema che contiene "cout"

using namespace std; //Attivo il namespace

return(result);

}

La funzione principale, come avrete notato, è il ''main()''. È una funzione particolare che di norma possiede come tipo resituito '''int'''. Talvolta è accettato anche bool e void. L'utilizzo di questa funzione verrà ripreso più avanti.

 

Questo è quello che "pensa" il compilatore. Se non ci fosse stato il prototipo, il compilatore non avrebbe saputo dove andare a cercare la funzione, generando un errore.

Ora che abbiamo spiegato a che cosa serve, spieghiamo come si usa. La definizione del puntatore può avvenire come con la funzione, cioè:

int prodotto(int x, int y); //RICORDATE IL ; !!!

oppure se non vogliamo "imporre" il nome dele variabili

int prodotto(int,int); //RICORDATE IL ; !!!

====Overloading====

I prototipi diventano utili quando si pratica l''''overloading''' delle funzioni. L'overloading non è possibile in [[C]], quindi è una novità di C++. L'overloading delle funzioni permette di dichiarare due funzioni con lo stesso nome ma con tipi differenti. Vediamo in pratica come funziona.

#include <iostream> //Libreria di sistema che contiene "cout"

using namespace std; //Attivo il namespace

return(p);

}

In questo modo il programma chiamerà in modo automatico la funzione appropriata in base al tipo di argomenti fornito. Ricordate che non è possibile mantenere gli stessi tipi argomenti, che anch'essi devono cambiare.

 

====La funzione main()====

La funzione ''main()'' (lavorando NON in win32) riceve due argomenti. Se non sono necessari possiamo ometterli come abbiamo fatto fino ad adesso. Il prototipo della funzione ''main'' "completa" si presenta come:

int main(int argc, char* argv[]);

*int argc: numero di argomenti

*char* argv[]: array degli argomenti

In questo caso gli argomenti vengono passati tramite: programma.exe argomento1 argomento2 ...<br />

Vediamo un esempio dell'utilizzo di questi:

#include <iostream>

 

return(0); //Mentre 0 di solito indica corretta esecuzione

}

L'utilizzo dello 0 e dell'1 nel return non causa alcun effetto, se non per alcuni debugger. L'esecuzione del programma non viene modificata.

 

<b>RICORDATEVI DI NON DIMENTICARE IL ; DOPO LA CHIUSURA DELLA CLASSE STESSA!!!</b><br />

Vediamo subito un esempio:

class carrello

{

int* codici_prodotti;

};

 

====Visibilità====

====Inizializzazione====

Per inizializzare una classe si utilizza:

nomeclasse nomeoggetto;

Esempio:

carrello CarrelloDellaSpesa;

In questo modo tutti i metodi e le variabili vengono richiamate con ''CarrelloDellaSpesa.nommemetodo();''.

====Implementazione====

Una classe senza l'implementazione dei metodi è pressocchè inutile (si potrebbe usare una '''struct''' in questo caso). I metodi (o funzioni) vengono implementati attraverso l'operatore di '''scope''':

void carrello::inserisci_prodotto(int codice)

{

return(codici_prodotti[numero]);

}

In questo modo è possbile richiamarli dalla main in questo programma (ipotizzando che l'implementazione sia in carrello.cpp e la definizione in carrello.h):

#include <iostream>

#include "carrello.h"

return(0);

}

 

===Template===

====Template di funzione====

Vediamo subito come si dichiarano.

template<typename T>

T è un qualunque identificatore valido. Questa istruzione va messa preferibilmente all'inizio del programma (o nell'header) e comunque prima della funzione che utilizzerà il template. Vediamo immediatamente un esempio concreto del suo utilizzo:

 

#include <iostream>

using namespace std;

stampaArray(arrayF,4);

}

Analizziamo il codice. Dopo aver dichiarato il template, la funzione ''stampaArray'' possiete un argomento che contiene il template. L'argomento è ''VAR *array''. Questa scrittura sostituisce la classica scrittura ''int *VAR'' e dato che è un array, si aggiunge la parola array '''dopo il segno di puntatore'''. Questo codice ha risparmiato tempo al programmatore che avrebbe dovuto scriversi i tre prototipi (e le relative funzioni) del tipo int, char e float.