3-12-2001
Per
utilizzare una variabile o una funzione in C++ è necessario dichiararla precedentemente
specificandone anche il tipo. Ad esempio:
| int a; | ||
è la dichiarazione (e la definizione della variabile) della variabile di nome a e di tipo int; il compilatore allocherà memoria sufficiente a contenere un numero int (vedi tipi dato).
|
extern int b;
|
||
Questa è una dichiarazione di una variabile già esistente in un altro file.
Un
esempio di dichiarazione di funzione è il seguente:
|
int
f (int , int);
|
||
La funzione prende in ingresso due valori interi (dentro le parentesi) e restituisce un intero (prima del nome).
La definizione di una variabile coincide con la dichiarazione (da non confondere con l'inizializzazione).
La definizione di funzione ne esprime il codice:
|
int f(int a, int b) {
} |
||
La funzione copia i valori in ingresso nelle variabili a e b dichiarate nell'intestazione. Fa il prodotto delle due variabili e lo mette nella variabile c definita ed inizializzata nella stessa riga. La funzione ritorna un valore int (come definito dalla dichiarazione) con il comando return.
Le librerie sono dei file che contengono un gran numero di variabili e di funzioni utili per la programmazione che possono venir utilizzate in fase di programmazione.
Un Header File contiene le dichiarazioni delle funzioni e delle variabili usate dalla libreria.
Ad esempio la fuzione sin ( ) che ritorna il seno di un numero, è dichirata all'interno dell'header file "math.h" e definita nella libreria corrispondente.
Le librerie e i rispettivi header files possono essere creati anche dal programmatore.
Per utilizzare una libreria è necessario includere il rispettivo header file nel codice del programma con il comando:
|
# include <iostream.h>
|
||
Che cerca il file nel path standard di ricerca
|
# include "iostream.h"
|
||
Che cerca nella directory locale: quella in cui risiede il programma.
In C++ (ma non in C) si puo scrivere il nome del file senza il .hanche se c'è differenza (vedi namesapces).
Gli header files contengono delle classi (iostream contiene le classi per l'input e l'output) e i rispettivi metodi. Una volta incluse le classi si possono usare gli oggetti.
Non è possibile avere infiniti nomi per classificare le variabili e le funzioni definite nelle librerie. Per evitare che due variabili con lo stesso nome ma definite in due header diversi vengano considerate come la stessa variabile dal compilatore, si definiscono dei namespaces: una variabile x definita in un header è diversa da una variabile x definita in un altro header. Per utilizzare questa opzione basta mettere il .h nell'inclusione dell'header oppure scrivere come segue:
|
# include <iostream>
|
||
|
using namespace std
|
||
Includendo l' header file iostream.h si possono utilizzare le classi per l'utilizzo dei metodi di input ed output (compresi gli standard tastiera e video). Due oggetti di queste classi sono cin e cout.
È contenuto nell'header iostream. Serve per stampare a video una serie di caratteri, il valore di una variabile, una stringa... ed utilizza l'operatore "output" <<. La sintassi è quella dell'esempio:
|
cout << "serie di caratteri" << x << "serie di caratteri" << 5 << endl; |
||
x è una variabile e con questo comando ne viene visualizzato il contenuto. 5 è un numero costante e viene stampato a video così com'è. Una serie di caratteri compresa tra " " viene chiamata stringa.
Endl è una costante di tipo char che contiene il carattere "\n" (a capo).
Sono contenuti in iostream.
Servono per visualizzare il valore di una variabile o di una costante in basi diverse. I manipolatori sono:
Manipolatore |
Conversione |
|
dec |
In base decimale |
|
oct |
In base ottale |
|
hex |
In base esadecimale |
|
char(numero) |
Simbolo ASCII corrispondente al numero |
Esempio di sintassi:
|
cout << "in hex: "
<< hex << x << endl;
|
||
Stampa il valore della variabile x in base esadecimale. (per dec e oct la sintassi non cambia)
|
cout << "carattere ASCII
(27): " << char(27) << endl; |
||
Stampa il carattere ASCII 27, che è il carattere escape.
È contenuto nell'header iostream. Serve per leggere da tastiera ed utilizza l'operatore "input" >>. La sintassi è quella dell'esempio:
|
cout << "inserisci un numero: "; cin >> x; |
||
cout visualizza il messaggio "inserisci un numero".
Quando l'utente inserisce il numero e preme invio questo viene salvato nella variabile x.
Viene fatta automaticamente la conversione del numero secondo il tipo della variabile (se x è di tipo int e viene inserito un numero float, nella variabile viene copiata solo la parte intera del numero e le altre operazioni vanno perse.
Le stringhe sono degli array di caratteri (cioè degli array di tipo char) terminati dal carattere "\0".
Questa classe è utilissima per manipolare le stringhe in modo semplice e senza ricorrere a trucchi di basso livello.
La sintassi si può dedurre dagli esempi:
|
string frase; |
||
|
frase = "Ciao, come stai"; |
||
è l'assegnazione della stringa: "frase" diventa una stringa lunga 16 caratteri più il carattere di fine stringa (che viene automaticamente aggiunto alla fine dell'espressione tra virgolette).
|
String frase2("Bene, grazie"); |
||
è l'inizializzazione della stringa frase2: comprende la dichiarazione e l'assegnazione.
|
frase = frase + " " +frase2; |
||
le tre stringhe vengono concatenate nel rispettivo ordine e copiate in frase (in frase c'è :"Ciao, come stai Bene grazie"). L'operatore + assume diversi significati in base al contesto in cui viene utilizzato. In questo caso concatena due stringhe (n.b. non le somma).
|
frase += " ! "; |
||
Appende in fondo alla stringa frase la stringa " ! ".
Fornisce un modo veloce e semplice per trattare la lettura e la scrittura su file. Spesso questo header comprende anche l'header <iostream>.
Per leggere da file:
|
ifstream leggi("nomefile");
|
||
Apre un canale di nome leggi per input dal file "nomefile".
Per scrivere su un file:
|
ofstream scrivi("nomefile2"); |
||
Apre un canale scrivi per scrivere sul file "nomefile".
Per leggere un file dall'inizio alla fine si utilizza un ciclo while (vedi while) di questo tipo:
| while (getline(leggi,linea)) | ||
| { scrivi << linea << "\n" | ||
|
...} |
||
La funzione getline contenuta in <fstream>, legge una riga alla volta (fino al "\n" o all' EOF esclusi, dove EOF è il carattere di fine file) dal canale leggi e la copia in linea (che è di tipo string). Al giro successivo legge automaticamente la riga successiva. Quando arriva alla fine del file ritorna il valore 0 e fa finire il ciclo.
Per scrivere su un file si utilizza l'operatore << come nell'esempio: ad ogni ciclo viene scritta sul canale scrivi una linea e un carattere "\n". Alla fine del ciclo nel file "nomefile2" c'è una copia esatta del file "nomefile".
Si può utilizzare anche l'operatore >> (similmente a <<) per leggere da file una parola alla volta (stavolta i separatori sono il "\n" lo " " e il "\t").
È una classe che può essere utilizzata con diversi tipi di dato. Non è necessario definire in fase di programmazione (compile time) la dimensione del vettore: ogni volta che viene aggiunto un nuovo elemento al vettore viene allocata dinamicamente (run time) la memoria necessaria a contenerlo.
È necessario dichiarare una variabile di tipo vector e specificare il tipo di dato che il vettore deve contenere:
| vector <string> v1; | // il vettore v1 è un vettore di stringhe | ||
|
vector <int> v2;
|
// il vettore v2 è un vettore di interi
|
||
Per inserire un nuovo elemento nel vettore si utilizza la funzione:
| v1.push_back("una stringa"); |
|||
| v2. push_back(45); |
|||
| v2.push_back(x); |
//dove x è di tipo int |
||
Il nuovo elemento viene inserito in fondo al vettore. Per accedere o modificare un elemento del vettore si utilizza la seguente sintassi (simile a quella degli array ma facendo attenzione alla dimensione del vettore):
| v1[3]="ciao"; | // il quarto elemento del vettore (v1[3]) deve già esistere | ||
| v2[5]=v2[3]+v2[4]-x+3; | // come sopra | ||
Attenzione: queste istruzioni non aggiungono un nuovo elemento al vettore ma ne modificano uno già esistente. Bisogna quindi sapere qual'è la dimensione del vettore prima di accedere ad uno dei suoi elementi per evitare di cercare un elemento che non esiste. Per conoscere la dimensione di un vettore si utilizza la funzione:
|
dim = v1.size(); // dim è di tipo int |
||
La funzione ritorna il numero di elementi che costituiscono il vettore (attenzione: il primo elemento è v1[0] e, se il vettore è di dimensione n, l'ultimo elemento è v1[n-1]).