Programmazione - Spiegazione C++, Puntatori e liste, Java (base)

Chiude il collegamento da lo stream f1 e il file

f1.close(); (successivamente si potrà usare f1 per creare un altro

collegamento).

Controlli Restituisce “true” se l'ultima operazione eseguita sullo

f1.fail() stream “f1” ha dato errore; in caso contrario, restituisce

“false”.

if (!f1) Altro metodo di controllo.

cout << "Errore apertura file" << endl; (f1 → input) In caso di errore di inserimento, ripristina lo

stato corretto dello stream (sposta il puntatore nella zone

f1.clear() precedente, dove è presente l'errore); sollo stream in

input però, è ancora presente l'errore, quindi si usa il

comando sotto.

(f1 → input) Svuota lo stream di input: estrae i caratteri

dallo stream in input; l'estrazione termina quando

f1.ignore(n,delim) vengono scartati “n” caratteri o quando si trova il

carattere “delim” (nel caso di “delim”, anch'esso viene

estratto).

Lettura caratteri Estrae dallo stream di input “f1” il carattere corrente e lo

f1.get() restituisce come suo risultato (dopo la “lettura”, lo

stream passa ad indicare il carattere successivo).

(f1 stream di input) restituisce “true” se l'ultima

f1.eof() operazione di lettura su f1 ha letto “end-of-fine” (indica

la fine del file); in caso contrario restituisce “false”.

Quando “f1.get()” incontra “end-of-fine” restituisce

f1.get() → EOF “EOF” come proprio contenuto, al posto di un carattere

(questo è un metodo alternativo al “fi.eof()” ).

(Con “c” variabile char) Assegna a “c” il carattere

estratto dal file, inoltre, restituisce anche un risultato

booleano:

- true: la get è riuscita a leggere il carattere e a passarlo a

f1.get(c) “c”.

- “false”: la get non è riuscita a leggere il carattere.

(Altro metodo alternativo per capire se la lettura è

avvenuta con successo).

while (f1.get(c)) Esercizio: conta i caratteri contenuti in un file.

num_car++; (si suppone “num_car” una variabile int uguale a 0).

Scrittura caratteri Scrive il valore di “e” (“e” può essere anche un

espressione) sullo stream di output di f2 nella posizione

f2.put(e) indicata dal puntatore al dato corrente, che viene poi

aggiornato di conseguenza.

ifstream in_file;

in_file.open("sorgente.txt");

ofstream out_file;

out_file.open("copia.txt");

char c; Esempio: Copia e incolla da file “sorgente” a file “copia”

do { (senza controlli).

c = in_file.get();

if (in_file.eof())

break;

out_file.put(c);

num_bytes++;

} while (true); Classi * = fuori dalla classe e dal main; altrimenti è dentro

class Pila {

… * Dichiarazione.

}; Funzioni e dati seguenti sono visibili e utilizzabili

public: anche al di fuori della classe

Funzioni e dati seguenti sono visibili e utilizzabili

private: solo all'interno della classe

Funzioni e dati seguenti sono visibili e utilizzabili

protected: solo all'interno della classe e nelle sottoclassi

Pila() { … } Costruttore dafault

Pila(int n, char c) { … } Costruttore con parametri

~Pila() { ...

delete[] A; //A è array Distruttore

delete a; //a e variabile singola

... } Funzione void; termina con “return;” (non restituisce

void push(int x) { … } niente)

Funzione; termina con “return a;” (restituisce una

int pop() { … } variabile “a” dello stesso tipo della funzione “int”)

Pila& operator= (const Pila& P) { ... Operatore =

for(int i=0; i<d; i++) Il “this” punta all'array “A[]” della classe; prima

A[i] = P.A[i]; riempio tale array facendolo diventare la copia, poi

Return *this; facendo “return *this;” restituisco il valore.

}

Razionale

operator+ (const Razionale& x) const {

Razionale risultato; Operatori + , - , * , /

risultato.d = d * x.d; Con questi operatori bisogna sempre usare i due const

Risultato.n = n * x.d + x.n * d; indicati in blu.

return risultato;

}

char& operator[] (int i) { ... Operatore []

Return A[i]; Restituisce un valore di tipo “char” in questo caso

}

bool operator== (const Pila& V) const {

...

If(...) Operatori == , < , <= , > , >= , !=

return true; Con questi operatori bisogna sempre usare i due const

else indicati in blu e il tipo della funzione è bool.

return false;

}

void stampa (ostream& s_out) const {

s_out << n << '/' << d;

} Funzioni stampa / leggi (interne)

void leggi (istream& s_in) { - stampa: bisogna utilizzare il const

int num, den; Per funzionare queste funzioni necessitano di altre due

char sep; funzioni (di seguito) che andranno messe fuori dalla

s_in >> num >> sep >> den; classe e fuori dal main

n = num;

D = den;

}

ostream& operator<<

(ostream& s_out, const Razionale& r) {

r.stampa(s_out);

return s_out;

} * Funzioni stampa / leggi (esterne)

Istream& operator>>

(istream& s_in, Razionale& r) {

r.leggi(s_in);

return s_in;

} Template (classe)

template <class T>

class vett

{ private: La riga blu è standard.

T *A; Si nota che:

int dim;

public: - T indica il tipo che varia a seconda della

... chiamata nel main (“vett<int>” del main,

vett<T> & operator= (const vett<T> & V) { farà in modo che “T *A;” della classe, sia

... utilizzato come “int *A;”). Il T lo si può

return *this; usare anche in altre funzioni come tipo

} (“T& operator[] (int i)...”).

T& operator[] (int i) { - Escludendo la dichiarazione “class vett”,

return A[i]; tutte le successive volte che si vorrà

} dichiarare il tipo “vett” nella classe, si

... dovrà scrivere “vett<T>”

}; - Per il resto è uguale ad una classe generica

int main() { senza template.

vett<int> V1;

vett<char> V2;

...

} Disposizione funzioni

Classe

class Razionale {

… - In azzurro è indicata la

Razionale operator/ (const Razionale& x) const; parte che si ripete sempre

void leggi (istream& s_in); uguale

…

}; - In arancio sono indicati i

tipi

Razionale Razionale:: operator/ (const Razionale& x) const {

… - In nero i nomi delle

return risultato; funzioni

} Le funzioni vanno scritte

come se fossero dentro la

void Razionale:: leggi (istream& s_in) { classe.

…

} Classe (template)

template <class T>

class vett {

...

vett<T>& operator=(const vett<T>& V);

T& operator[](int i);

int operator==(const vett<T>& V) const;

}; - In azzurro è indicata la

parte che si ripete sempre

template <class T> uguale

vett<T>& vett<T>:: operator= (const vett<T>& V) {

... - In arancio sono indicati i

return *this; tipi

} - In nero i nomi delle

template <class T> funzioni

T& vett<T>:: operator[] (int i) { Le funzioni vanno scritte

... come se fossero dentro la

return A[i]; classe.

}

template <class T>

int vett<T>:: operator== (const vett<T>& V) const {

...

return 1;

} Codici particolari

int main() {

Try {

... //codice main Per controllare eventuali errori nel codice main

} (trovati tramite throw).

catch(const char* str) { Al posto di scrivere “cout << “errore”;”, bisogna

cerr << "Eccezione: " << str << endl; scrivere “throw “errore”;”.

}

}

f_in.open(nome_file); Estrae automaticamente un valore “float” dal file

float c1; (funziona anche per altri tipi).

f_in >> c1; Se l'utente inserisce “34/25”, il codice

riconoscerà automaticamente i due numeri e il

int num, den, g, m, a; carattere assegnandoli alle rispettive variabili

char sep; (num, sep, den).

cin >> num >> sep >> den; Se l'utente inserisce “34 45 23” il codice

Cin >> g >> m >> a; riconoscerà automaticamente i tre numeri

assegnandoli alle rispettive variabili (g,m,a).

char A='a'; A conterrà “A” alla fine.

A = toupper(A); * = operazioni dove è necessaria la libreria

Vettore di caratteri “#include <cstring>”

char s[10] = “ciao”; Dichiarazione.

char s[] = “ciao”, r[10]; Dichiarazione (con lunghezza automatica).

Inserisce tutti i caratteri trovati in input fino a che

non trova “spazio” o “a capo” (se inserisco “Aldo

cin >> s; Tragni” la stringa conterrà solo ''Aldo'' seguito da

“\0”).

s → stringa, 9 → numero massimo di caratteri

considerati, \n → indica il carattere che, quando

cin.getline(s,9,'\n'); viene incontrato, fa terminare la lettura.

Alla fine verrà aggiunto “\0” alla stringa.

strlen(s); * Lunghezza della stringa “s”.

strcpy(s,r); * Copia la stringa “r” in “s”.

* Concatena la stringa “r” alla stringa “s”

strcat(s,r); (Attenzione! “s” deve avere una dimensione tale

da poter contenere entrambe le stringhe).

strcmp(s,r); * s = r → 0 ; s < r → -1 ; s > r → +1

char *P; * Cerca il carattere 'a' e se lo trova fa in modo che

P = strchr(s,'a'); il puntatore *P punti all'a' trovato.

Stringhe

string s0; // stringa vuota

string s1(“ciao”) // s2 contiene “ciao”

string s2(s1); // crea s2, copiandovi poi s1 Dichiarazione.

string s3(‘x’); // s3 contiene la stringa “x” ( Se non include automaticamente la libreria

char *ps = “Salve a tutti”; string, allora usare “#include <string>” )

string s4(ps); // s4 contiene “Salve a tutti”

string s5(s4, 3,10) // s5 contiene “ve a tut” Legge una parola (“Aldo Tragni” → aggiunge

cin >> str; solo “Aldo” alla stringa str)

Legge l'intera riga (“Aldo Tragni” → aggiunge

getline(cin, str); “Aldo Tragni” alla stringa)

string S3 = S1 + “ “ + S2; Si possono concatenare due stringhe con il +

#include <cmath> (double x)

cos(x) , sin(x) , tan(x) , log(x) , log10(x)

exp(x) , sqrt(x) Esponenziale , radice