a005prim.cpp
<![CDATA[
#include <iostream>
using namespace std;
int main() {
cout << "Questo e' il mio primo programma C++.\n";
return 0;
}
]]>
a010prim.cpp
<![CDATA[
#include<iostream>
using namespace std; int main(){cout<<"Anche questo potrebbe essere il mio primo programma.\n";return 0;}
]]>
a015prim.cpp
<![CDATA[
#include <iostream>
using
namespace std;
int
main
(
)
{ cout <<
"... e anche questo!\n"
; return
0
;
}
]]>
a020comm.cpp
<![CDATA[
// Questo e' un <commento>
#include <iostream>
using namespace std;
int main// un commento puo' cominciare in qualsiasi posizione
// ma termina alla fine della riga
( // la parentesi chiusa alla fine di questa riga fa parte del commento)
)
{ // comincia il corpo del programma
cout << "Commentiamo!\n";
return 0;}
// questo commento si trova dopo la fine del programma
]]>
a025prim.cpp
<![CDATA[
#include <iostream> // Direttiva per il preprocessore: include il file
// di intestazione 'iostream' sul quale si basa
// il sistema di I/O del C++.
using namespace std; // indico di utilizzare lo spazio dei nomi std,
// in questo spazio sono definite le principali funzioni
// di input/output che useremo durante il corso
int main() // Intestazione della funzione principale (main):
// indica dove ha inizio l'esecuzione del programma.
// La coppia di parentesi tonde e' obbligatoria e
// potra' in futuro contenere dei 'parametri'.
{ // Parentesi graffa aperta: delimitatore di apertura
// del corpo della funzione main.
cout << "Primo esempio\n"; // Visualizza la frase 'Primo esempio' e
// posiziona il cursore all'inizio della riga
// successiva;
// cout sta per "console output" e rappresenta
// il flusso standard di output;
// il simbolo << e' l'operatore di inserimento
return 0; // La funzione (main) restituisce il valore 0
} // Parentesi graffa chiusa: delimitatore di chiusura
// del corpo della funzione main
]]>
a030altr.cpp
<![CDATA[
// nuovi concetti: sequenze di <<
#include <iostream>
using namespace std;
int main() {
cout << "Altro " << "esempio\n"; // Visualizza 'Altro esempio'
// "Altro " ed "esempio\n" sono stringhe letterali;
// '\n' (newline: a capo) e' una 'sequenza di escape'
return 0;
}
]]>
a035cout.cpp
<![CDATA[
// nuovi concetti: costante intera, espressione intera
// nuovi elementi: -, *, +
#include <iostream>
using namespace std;
int main() {
cout << 4 - 3 * 6 + 2 << "\n"; // visualizza il risultato dell'espressione:
// -12
return 0;
}
]]>
a040cout.cpp
<![CDATA[
// nuovi elementi: endl
#include <iostream>
using namespace std;
int main() {
cout << "4 - 3 * 6 + 2 = " << 4 - 3 * 6 + 2 << endl;
// 'endl' e' un "manipolatore di stream" che
// introduce un carattere di fine riga
return 0;
}
/* Output:
4 - 3 * 6 + 2 = -12
*/
]]>
a045intv.cpp
<![CDATA[
// nuovi concetti: variabile, assegnamento
// nuovi elementi: int, =
#include <iostream>
using namespace std;
int main() {
int a; // dichiara 'a' come variabile di tipo 'int':
// a puo' assumere un qualsiasi valore intero
// nell'intervallo -2147483648 ... +2147483647
a = -2; // assegna il valore -2 alla variabile a
cout << a << endl; // visualizza il contenuto della variabile a
return 0;
}
]]>
a050iniz.cpp
<![CDATA[
// nuovi concetti: dichiarazione e inizializzazione di una variabile
// espressione con variabili
#include <iostream>
using namespace std;
int main() {
int x = 12; // dichiara e inizializza la variabile x
cout << x*x+2*x; // visualizza il risultato dell'espressione: '168'
cout << endl;
return 0;
}
]]>
a055asse.cpp
<![CDATA[
// nuovi concetti: dichiarazione di piu' variabili
// dichiarazione e inizializzazione nel corpo del programma
#include <iostream>
using namespace std;
int main() {
int x, y1; // dichiara le variabili x e y1
x = 77;
y1 = 88;
int y2 = 55; // dichiara e inizializza a 55 la variabile y2
cout << x << ", " << y1 << ", " << y2 << endl;
return 0;
}
/* Output:
77, 88, 55
*/
]]>
a060iniz.cpp
<![CDATA[
// nuovi concetti: dichiarazione di piu' variabili
// con inizializzazione di alcune
#include <iostream>
using namespace std;
int main() {
int n1, n2 = 55, n3, n4, n5 = 44, n6;
cout << n2 << ", " << n5 << endl;
return 0;
}
/* Output:
55, 44
*/
]]>
a065asse.cpp
<![CDATA[
// nuovi concetti: assegnazione come espressione
#include <iostream>
using namespace std;
int main() {
int m, n;
m = (n = 66) + 9; // (n = 66) e' un'espressione di assegnazione
cout << m << ", " << n << endl;
return 0;
}
/* Output:
75, 66
*/
]]>
a070espr.cpp
<![CDATA[
// nuovi concetti: divisione tra interi
// nuovi elementi: /
#include <iostream>
using namespace std;
int main() {
cout << "2 + 5 * 7 / 2 = "
<< 2 + 5 * 7 / 2 // visualizza il risultato (19)
<< endl; // e poi va a capo
cout << "(2 + 5) * 7 / 2 = "
<< (2 + 5) * 7 / 2 // risultato: 24
<< endl;
return 0;
}
/* Output:
2 + 5 * 7 / 2 = 19
(2 + 5) * 7 / 2 = 24
*/
]]>
a075oper.cpp
<![CDATA[
// nuovi elementi: &percnt;
#include <iostream>
using namespace std;
int main() {
int m = -14, n = 5, q = m/n, r = m&percnt;n;
cout << "m = " << m << endl;
cout << "n = " << n << endl;
cout << "q = " << q << endl;
cout << "r = " << r << endl;
cout << "q*n + r = " << "(" << q << ")*(" << n << ") + "
<< r << " = " << q*n + r << " = " << m << endl;
return 0;
}
/* Output:
m = -14
n = 5
q = -2
r = -4
q*n + r = (-2)*(5) + -4 = -14 = -14
*/
]]>
a080cin.cpp
<![CDATA[
// nuovi concetti: input da tastiera
// nuovi elementi: cin, >>
#include <iostream>
using namespace std;
int main() {
int x;
cout << "Introduci un numero intero: ";
cin >> x; // assegna ad x il numero intero
// introdotto da tastiera
// cin sta per "console input" e rappresenta
// il flusso standard di input;
// il simbolo >> e' l'operatore di input
cout << "Il quadrato di " << x << " e' " << x*x << endl;
// visualizza il quadrato del numero introdotto da tastiera
return 0;
}
]]>
a085if.cpp
<![CDATA[
// nuovi concetti: selezione, espressione di relazione
// nuovi elementi: if, <
#include <iostream>
using namespace std;
int main() {
int n;
cout << "Introduci un numero intero: ";
cin >> n;
if (n < 0) n = -n; // se n<0 allora cambia segno
cout << "valore assoluto = " << n << endl;
return 0;
}
]]>
a090else.cpp
<![CDATA[
// nuovi concetti: selezione a due vie
// nuovi elementi: ==, else
#include <iostream>
using namespace std;
int main() {
int n;
cout << "Introduci un numero intero: ";
cin >> n;
cout << "Il numero " << n << " e' ";
if (n &percnt; 2 == 0) cout << "pari"; // se n e' divisibile per 2
// visualizza 'pari'
else cout << "dispari"; // altrimenti visualizza 'dispari'
cout << endl;
return 0;
}
]]>
a095else.cpp
<![CDATA[
// nuovi concetti: diverso da zero equivale a vero
#include <iostream>
using namespace std;
int main() {
int n;
cout << "Introduci un numero intero: ";
cin >> n;
cout << "Il numero " << n << " e' ";
if (n &percnt; 2) cout << "dispari";
else cout << "pari";
cout << endl;
return 0;
}
]]>
a100cort.cpp
<![CDATA[
// nuovi concetti: operatore AND
// cortocircuito nel calcolo di una espressione logica
// nuovi elementi: >, &&
#include <iostream>
using namespace std;
int main() {
int n, d;
cout << "Introduci due interi positivi: ";
cin >> n >> d;
if (d > 0 && n&percnt;d == 0) cout << d << " e' un divisore di " << n << endl;
else cout << d << " non e' un divisore di " << n << endl;
return 0;
}
]]>
a105whil.cpp
<![CDATA[
// nuovi concetti: iterazione
// nuovi elementi: while
#include <iostream>
using namespace std;
// Calcola il Massimo Comune Divisore (MCD) di due numeri interi
// applicando l'algoritmo di Euclide
int main() {
int numeroA, numeroB, a, b, r; // dichiara 5 variabili di tipo int
cout << "----- Massimo Comune Divisore -----\n";
cout << "Introdurre due numeri interi positivi:\n";
cin >> numeroA >> numeroB; // legge due interi da tastiera e li assegna
// rispettivamente a numeroA e numeroB
a = numeroA; // assegna ad a il valore di numeroA
b = numeroB; // assegna a b il valore di numeroB
r = a &percnt; b; // assegna a r il resto di a diviso b
while (r > 0){ // mentre r e' maggiore di 0 continua ad eseguire
// le seguenti istruzioni (racchiuse tra '{' e '}')
a = b;
b = r;
r = a &percnt; b;
}
// il ciclo 'while' e' terminato: r non e' piu' maggiore di 0
// (cioe', e' uguale a 0) => b e' il MCD
cout << "MCD (" << numeroA << "," << numeroB << ") = " << b << endl;
return 0;
}
]]>
a110dowh.cpp
<![CDATA[
// nuovi elementi: do-while
#include <iostream>
using namespace std;
// Calcola il Massimo Comune Divisore (MCD) di due numeri interi
int main() {
int a, b, r;
cout << "----- Massimo Comune Divisore -----\n";
cout << "Introdurre due numeri interi positivi:\n";
cin >> a >> b;
cout << "MCD (" << a << "," << b << ") = ";
do{ // esegui le istruzioni racchiuse tra '{' e '}'
r = a &percnt; b; // ...
a = b;
b = r; // ...
}
while (r > 0); // mentre r e' maggiore di 0
// il ciclo 'do-while' e' terminato: r e' uguale a 0 => a e' il MCD
cout << a << endl;
return 0;
}
]]>
a115mcd.cpp
<![CDATA[
// nuovi concetti: cicli annidati
#include <iostream>
using namespace std;
// Calcola il Massimo Comune Divisore (MCD) di due numeri interi
int main() {
int a, b, r;
cout << "----- Massimo Comune Divisore -----\n";
cout << "Introdurre due numeri interi positivi (0 0 per finire):\n";
cin >> a >> b;
while (a > 0 && b > 0) // il ciclo termina quando il prodotto da' 0
{ // inizio blocco del ciclo esterno
cout << "MCD (" << a << "," << b << ") = ";
do{ // inizio blocco del ciclo interno
r = a &percnt; b;
a = b;
b = r;
} // fine blocco del ciclo interno
while (r);
cout << a << endl;
cin >> a >> b;
} // fine blocco del ciclo esterno
return 0;
}
]]>
a120incr.cpp
<![CDATA[
// nuovo concetti: preincremento e postincremento
// nuovi elementi: ++
#include <iostream>
using namespace std;
int main() {
int m = 66, n;
n = ++m;
cout << "m = " << m << ", n = " << n << endl;
n = m++;
cout << "m = " << m << ", n = " << n << endl;
cout << "m = " << m++ << endl;
cout << "m = " << m << endl;
cout << "m = " << ++m << endl;
return 0;
}
/* Output:
m = 67, n = 67
m = 68, n = 67
m = 68
m = 69
m = 70
*/
]]>
a125blok.cpp
<![CDATA[
// nuovi concetti: variabile locale al blocco
#include <iostream>
using namespace std;
int main() {
int x, y;
cout << "Introduci due interi: ";
cin >> x >> y;
if (x > y){
int temp = x; // la variabile temp e' locale al blocco
x = y; // racchiuso tra le parentesi graffe
y = temp;
}
cout << "I due interi ordinati sono: ";
cout << x << " " << y << endl;
// cout << temp; // questa istruzione produrrebbe un errore di compilazione
return 0;
}
]]>
a130over.cpp
<![CDATA[
// nuovi concetti: overflow (traboccamento)
#include <iostream>
using namespace std;
int main() {
int n = 2147483646;
cout << n++ << endl;
cout << n++ << endl;
cout << n++ << endl;
cout << n++ << endl;
return 0;
}
]]>
a135char.cpp
<![CDATA[
// nuovi concetti: costante carattere, caratteri come interi
// nuovi elementi: char
#include <iostream>
using namespace std;
int main() {
char c = 'A';
cout << c++ << " ";
cout << c++ << " ";
cout << c++ << " ";
cout << c++ << endl;
c = 97; // 97 e' il codice ASCII della lettera 'a'
cout << c++ << " ";
cout << c++ << " ";
cout << c++ << " ";
cout << c++ << endl;
return 0;
}
/* Output:
A B C D
a b c d
*/
]]>
a140char.cpp
<![CDATA[
// nuovi concetti: type cast
#include <iostream>
using namespace std;
int main() {
char c = 'A';
cout << c << " " << int(c) << endl;
c++;
cout << c << " " << int(c) << endl;
c++;
cout << c << " " << int(c) << endl;
return 0;
}
/* Output:
A 65
B 66
C 67
*/
]]>
a145char.cpp
<![CDATA[
// nuovi concetti: input di caratteri
#include <iostream>
using namespace std;
int main() {
char first, last;
cout << "Introduci le iniziali del tuo nome e cognome: ";
cin >> first >> last;
cout << "Salve, " << first << ". " << last << ".!\n";
return 0;
}
]]>
a150limi.cpp
<![CDATA[
// nuovi concetti: modificatori (short, long, signed, unsigned)
#include <iostream>
using namespace std;
int main() {
cout << "minimum char = " << CHAR_MIN << endl;
cout << "maximum char = " << CHAR_MAX << endl;
cout << "minimum short = " << SHRT_MIN << endl;
cout << "maximum short = " << SHRT_MAX << endl;
cout << "minimum int = " << INT_MIN << endl;
cout << "maximum int = " << INT_MAX << endl;
cout << "minimum long = " << LONG_MIN << endl;
cout << "maximum long = " << LONG_MAX << endl;
cout << "minimum signed char = " << SCHAR_MIN << endl;
cout << "maximum signed char = " << SCHAR_MAX << endl;
cout << "maximum unsigned char = " << UCHAR_MAX << endl;
cout << "maximum unsigned short = " << USHRT_MAX << endl;
cout << "maximum unsigned int = " << UINT_MAX << endl;
cout << "maximum unsigned long = " << ULONG_MAX << endl;
return 0;
}
]]>
a155for.cpp
<![CDATA[
// nuovi elementi: for, <=
#include <iostream>
using namespace std;
int main() {
int n;
// for (<inizializzazione>; <condizione di iterazione>; <aggiornamento>) <istruzione>
for (n = 1; n <= 10; n++)
cout << n << " ";
cout << endl;
return 0;
}
/* Output:
1 2 3 4 5 6 7 8 9 10
*/
]]>
a160asci.cpp
<![CDATA[
// nuovi concetti: tabella ASCII
#include <iostream>
using namespace std;
int main(){
int ascii_val;
for (ascii_val = 32; ascii_val < 256; ascii_val++)
{
if (ascii_val &percnt; 4 == 0) cout << '\n';
cout << '\t' << ascii_val << '\t' << char(ascii_val);
}
cout << endl;
return 0;
}
]]>
a165tabe.cpp
<![CDATA[
// nuovi concetti: variabile dichiarata nell'inizializzazione del for
#include <iostream>
using namespace std;
int main() {
int n;
cout << "Introduci un numero intero: ";
cin >> n;
cout << "Tabellina del " << n << endl;
for (int m = 1; m <= 10; m++)
cout << n * m << endl;
return 0;
}
]]>
a170for.cpp
<![CDATA[
// nuovi elementi: operatore ","
#include <iostream>
using namespace std;
int main() {
int m, n;
for (m = 1, n = 8; m < n; m++, n--)
cout << "m = " << m << ", n = " << n << endl;
return 0;
}
/* Output:
m = 1, n = 8
m = 2, n = 7
m = 3, n = 6
m = 4, n = 5
*/
]]>
a175for.cpp
<![CDATA[
// nuovi concetti: for ( ; ; )
// nuovi elementi: +=, float, break
#include <iostream>
using namespace std;
int main() {
int n, count = 0, sum = 0;
cout << "Introduci interi positivi. Termina l'input con 0:\n";
for ( ; ; ) {
cout << '\t' << count + 1 << ": ";
cin >> n;
if (n == 0) break;
++count;
sum += n;
}
cout << "La media dei " << count << " numeri e' " << float(sum)/count << endl;
return 0;
}
]]>
a180for.cpp
<![CDATA[
// nuovo concetti: corpo del for vuoto
#include <iostream>
using namespace std;
int main(){
int num, totale;
for (num = 1, totale = 0; num <= 10; totale += num++);
cout << "\nLa somma dei numeri da 1 a 10 e' "<< totale << endl;
return 0;
}
]]>
a185divi.cpp
<![CDATA[
#include <iostream>
using namespace std;
int main() {
cout << "Calcola i divisori di un numero intero." << endl;
int numero;
do {
cout << "Introduci un numero intero (<=0 per finire): " << endl;
cin >> numero;
if (numero > 0) {
cout << "i divisori di " << numero << " sono: " << endl;
for (int divisore = 2; divisore <= numero; divisore++)
if (numero &percnt; divisore == 0)
cout << divisore << endl;
}
cout << endl;
} while (numero > 0);
return 0;
}
]]>
a190ando.cpp
<![CDATA[
// nuovi elementi: >=, ||
#include <iostream>
using namespace std;
int main() {
int n;
do {
cout << "Dammi un numero tra 10 e 20." << endl;
cin >> n;
if (n >= 10 && n <= 20) cout << "Grazie!";
else cout << "Il tuo numero non e' compreso nell'intervallo 10-20\n";
} while (n < 10 || n > 20);
return 0;
}
]]>
a195depo.cpp
<![CDATA[
// nuovo concetti: variabili di tipo float
#include <iostream>
using namespace std;
int main() {
int anni, contanni;
float npercento, euro, interesse_corrente_anno, interesse_totale;
cout << " Calcolo dell'interesse accumulato\n";
cout << " ---------------------------------\n";
cout << "Introdurre la durata del deposito in anni (max 30), la cifra "
<< "depositata\n";
cout << "in euro e il tasso di interesse\n";
cin >> anni >> euro >> npercento;
cout << endl << endl;
if (anni<=0 || anni>30 || euro<=0 || npercento<=0) {
cout << " dati forniti: anni == " << anni
<< ", euro == " << euro
<< ", npercento == " << npercento
<< "\n dati non validi - programma interrotto.\n";
}
else {
cout << " introiti su un deposito di " << euro
<< " euro\n"
<< " tenuto per " << anni
<< " anni\n"
<< " ad un interesse annuale composto del " << npercento
<< " percento\n"
<< " -------------------------------------------------------------------\n"
<< " numero interesse capitale interesse\n"
<< " anno annuale accumulato\n"
<< " -------------------------------------------------------------------\n";
for (contanni=1, interesse_totale=0; contanni<=anni; contanni++) {
interesse_corrente_anno = (euro * npercento) / 100;
interesse_totale += interesse_corrente_anno;
euro += interesse_corrente_anno;
cout << contanni << " " << interesse_corrente_anno << " " << euro
<< " " << interesse_totale << endl;
}
cout << " -------------------------------------------------------------------\n";
}
return 0;
}
]]>
a200depo.cpp
<![CDATA[
// nuovi elementi: iomanip, setw, setprecision, setf, ::
#include <iostream>
#include <iomanip> // permette di usare setw, setprecision e setf
using namespace std;
int main() {
int anni, contanni;
float npercento, euro, interesse_corrente_anno, interesse_totale;
cout << " Calcolo dell'interesse accumulato\n";
cout << " ---------------------------------\n";
cout << "Introdurre la durata del deposito in anni (max 30), la cifra "
<< "depositata\n";
cout << "in euro e il tasso di interesse\n";
cin >> anni >> euro >> npercento;
cout << endl << endl;
if (anni<=0 || anni>30 || euro<=0 || npercento<=0) {
cout << " dati forniti: anni == " << anni
<< ", euro == " << euro
<< ", npercento == " << npercento
<< "\n dati non validi - programma interrotto.\n";
}
else {
cout << " introiti su un deposito di "
<< setw(8) << euro
<< " euro\n"
<< " tenuto per "
<< setw(8) << anni
<< " anni\n"
<< " ad un interesse annuale composto del "
<< setw(8) << npercento
<< " percento\n"
<< " -----------------------------------------------------------------\n"
<< " numero interesse capitale interesse\n"
<< " anno annuale accumulato\n"
<< " -----------------------------------------------------------------\n";
// cout.setf(ios::showpoint);
cout.setf(ios::fixed, ios::floatfield);
for (contanni=1, interesse_totale=0; contanni<=anni; contanni++) {
interesse_corrente_anno = (euro * npercento) / 100;
interesse_totale += interesse_corrente_anno;
euro += interesse_corrente_anno;
cout << setprecision(3);
cout << setw(10) << contanni;
cout << setw(18) << interesse_corrente_anno;
cout << setw(16) << euro;
cout << setw(14) << interesse_totale << endl;
}
cout << " -----------------------------------------------------------------\n";
}
return 0;
}
]]>
a205cast.cpp
<![CDATA[
// nuovi concetti: assegnare un reale a un intero
// nuovi elementi: double
#include <iostream>
using namespace std;
int main()
{
double v = 1234.56789;
//int n = int(v);
int n = v;
cout << "v = " << v << ", n = " << n << endl;
v = n;
cout << "v = " << v << ", n = " << n << endl;
return 0;
}
/* Output:
v = 1234.57, n = 1234
v = 1234, n = 1234
*/
]]>
a210scop.cpp
<![CDATA[
// nuovi concetti: ambito di visibilita' (scope)
#include <iostream>
using namespace std;
int main()
{ // inizio ambito di main()
int x = 22;
{ // inizio ambito di blocco interno
int x = 33;
cout << "Nel blocco interno a main(): x = " << x << endl;
} // fine ambito di blocco interno
cout << "In main(): x = " << x << endl;
return 0;
} // fine ambito di main()
/* Output:
Nel blocco interno a main(): x = 33
In main(): x = 22
*/
]]>
a215cond.cpp
<![CDATA[
// nuovi elementi: ?: (operatore di espressione condizionale
// o operatore ternario)
#include <iostream>
using namespace std;
int main() {
int n;
cout << "Introduci un numero intero: ";
cin >> n;
cout << "Il numero " << n << " e' "
<< (n &percnt; 2 ? "dispari" : "pari") << endl;
return 0;
}
]]>
a220aray.cpp
<![CDATA[
// nuovi concetti: array
// nuovi elementi: []
#include <iostream>
using namespace std;
int main() {
int i, a[6];
cout << "Introduci 6 numeri interi.\n";
for (i = 0; i < 6; i++)
cin >> a[i];
cout << endl;
for (i = 5; i >= 0; i--)
cout << a[i] << endl;
}
]]>
a225cost.cpp
<![CDATA[
// nuovi concetti: costanti
// nuovi elementi: const
#include <iostream>
using namespace std;
int main() {
const int n = 6; // meglio usare costante!
int a[n], i;
cout << "Introdurre " << n << " interi\n";
for (i = 0; i < n; i++)
cin >> a[i];
cout << endl;
for (i = n; i > 0; i--)
cout << a[i-1] << endl;
}
]]>
a230aray.cpp
<![CDATA[
// nuovi concetti: inizializzazione di un array
#include <iostream>
using namespace std;
int main() {
double a[4] = {22.2, 44.4, 66.6, 88.8};
for (int i = 0; i < 4; i++)
cout << "a[" << i << "] = " << a[i] << endl;
}
/* Output:
a[0] = 22.2
a[1] = 44.4
a[2] = 66.6
a[3] = 88.8
*/
]]>
a235matr.cpp
<![CDATA[
// nuovi concetti: array bidimensionale, for annidato
#include <iostream>
using namespace std;
int main() {
const int dim = 3;
int i, j, m[dim][dim];
cout << "Introdurre matrice (" << dim << "x" << dim << ")\n";
for (i=0; i<dim; i++)
for (j=0; j<dim; j++)
cin >> m[i][j];
cout << "\nMatrice introdotta:\n";
for (i=0; i<dim; i++) {
for (j=0; j<dim; j++)
cout << m[i][j] << " ";
cout << endl;
}
cout << "\nMatrice trasposta:\n";
for (i=0; i<dim; i++) {
for (j=0; j<dim; j++)
cout << m[j][i] << " ";
cout << endl;
}
}
]]>
a240tdef.cpp
<![CDATA[
// nuovi elementi: typedef
#include <iostream>
using namespace std;
int main() {
const int DIM = 6;
typedef int Vettore[DIM];
int i;
Vettore a;
cout << "Introduci " << DIM << " numeri interi.\n";
for (i=0; i<DIM; i++)
cin >> a[i];
cout << endl;
for (i=DIM; i>0; i--)
cout << a[i-1] << endl;
}
]]>
a245matr.cpp
<![CDATA[
#include <iostream>
using namespace std;
int main() {
const int DIM = 3;
typedef int Matrice[DIM][DIM];
int i, j;
Matrice m, t;
cout << "Introdurre matrice (" << DIM << 'x' << DIM << ")\n";
for (i=0; i<DIM; i++) {
for (j=0; j<DIM; j++)
cin >> m[i][j];
}
for (i=0; i<DIM; i++)
for (j=0; j<DIM; j++)
t[i][j] = m[j][i];
cout << "\nMatrice introdotta:\n";
for (i=0; i<DIM; i++) {
for (j=0; j<DIM; j++)
cout << m[i][j] << " ";
cout << endl;
}
cout << "\nMatrice trasposta:\n";
for (i=0; i<DIM; i++) {
for (j=0; j<DIM; j++)
cout << t[i][j] << " ";
cout << endl;
}
}
]]>
a250strn.cpp
<![CDATA[
// nuovi concetti: array di char
// nuovi elementi: sizeof()
#include <iostream>
using namespace std;
int main() {
char s[] = {'A', 'B', 'C', 'D'};
for (int i=0; i<sizeof(s); i++)
cout << "s[" << i << "] = '" << s[i] << "', " << int(s[i]) << "\n";
}
]]>
a255strn.cpp
<![CDATA[
// nuovi concetti: variabile stringa
#include <iostream>
using namespace std;
int main() {
char s[] = "ABCD"; /* equivale a
char s[] = {'A', 'B', 'C', 'D', '\0'}; */
for (int i=0; i<sizeof(s); i++)
cout << "s[" << i << "] = '" << s[i] << "', " << int(s[i]) << "\n";
}
]]>
a260stln.cpp
<![CDATA[
// nuovi concetti: stringa vuota ("")
// nuovi elementi: strlen()
#include <iostream>
using namespace std;
int main() {
char s[] = "Hello, World.\n";
cout << strlen(s) << '\n';
s[strlen(s)-1] = 0;
cout << strlen(s) << '\n';
cout << strlen("Hello, ") << '\n';
cout << strlen("H") << '\n';
cout << strlen("") << '\n';
return 0;
}
/* Output:
14
13
7
1
0
*/
]]>
a265strc.cpp
<![CDATA[
// nuovi concetti: confronto tra stringhe
// nuovi elementi: strcmp()
#include<iostream>
using namespace std;
int main(){
char a[]="Fondamenti";
char b[]="Fondamenti";
char c[]="Bertozzi";
cout << "a=[" << a << "]\n";
cout << "b=[" << b << "]\n";
cout << "c=[" << c << "]\n";
if(a==b)
cout << "I valori di a e b sono uguali" << endl;
else
cout << "I valori di a e b sono differenti" << endl;
cout << " a==b: " << (a==b) << endl;
cout << " strcmp(a,b): " << strcmp(a,b) << endl;
cout << " strcmp(a,c): " << strcmp(a,c) << endl;
cout << " strcmp(c,a): " << strcmp(c,a) << endl;
return 0;
}
]]>
a270stcp.cpp
<![CDATA[
// nuovi concetti: copiare una stringa su un'altra
// nuovi elementi: strcpy()
#include <iostream>
using namespace std;
int main() {
char s1[] = "ABCDEFG";
char s2[] = "XYZ";
cout << "Prima di strcpy(s1,s2):\n";
cout << "\ts1 = [" << s1 << "], lunghezza = " << strlen(s1) << endl;
cout << "\ts2 = [" << s2 << "], lunghezza = " << strlen(s2) << endl;
strcpy(s1,s2);
cout << "Dopo strcpy(s1,s2):\n";
cout << "\ts1 = [" << s1 << "], lunghezza = " << strlen(s1) << endl;
cout << "\ts2 = [" << s2 << "], lunghezza = " << strlen(s2) << endl;
}
]]>
a275stct.cpp
<![CDATA[
// nuovi concetti: concatenazione di stringhe
// nuovi elementi: strcat()
#include <iostream>
using namespace std;
int main() {
char s1[11] = "ABCDEFG";
char s2[] = "XYZ";
cout << "Prima di strcat(s1,s2):\n";
cout << "\ts1 = [" << s1 << "], lunghezza = " << strlen(s1) << endl;
cout << "\ts2 = [" << s2 << "], lunghezza = " << strlen(s2) << endl;
strcat(s1,s2);
cout << "Dopo strcat(s1,s2):\n";
cout << "\ts1 = [" << s1 << "], lunghezza = " << strlen(s1) << endl;
cout << "\ts2 = [" << s2 << "], lunghezza = " << strlen(s2) << endl;
}
]]>
a280cin.cpp
<![CDATA[
// nuovi concetti: risultato di cin, ^Z
#include <iostream>
using namespace std;
int main() {
int n, sum=0;
while (cin >> n)
sum += n;
cout << "somma = " << sum << endl;
}
]]>
a285strl.cpp
<![CDATA[
#include <iostream>
using namespace std;
int main() {
char s[] = "ABCDEFG";
cout << "strlen(" << s << ") = " << strlen(s) << endl;
char t[] = "";
cout << "strlen(\"\") = " << strlen(t) << endl;
char buffer[80];
cout << "Introduci stringa: "; cin >> buffer;
cout << "strlen(" << buffer << ") = " << strlen(buffer) << endl;
}
]]>
a290getl.cpp
<![CDATA[
// nuovi elementi: cin.getline()
#include <iostream>
using namespace std;
int main() {
char line[80];
do {
cin.getline(line, 80);
if (line[0]) cout << "\t[" << line << "]\n";
} while (line[0]);
}
]]>
a295maca.cpp
<![CDATA[
// nuovi concetti: array di stringhe
#include <iostream>
using namespace std;
int main() {
char name[8][24];
int count;
cout << "Introduci non piu' di 8 nomi di non piu' di 23 caratteri:\n";
for (count=0; count < 8 && cin.getline(name[count],24); ++count)
;
cout << "I nomi sono:\n";
for (int i = 0; i < count; i++)
cout << '\t' << i << ". [" << name[i] << "]" << endl;
}
]]>
a300cing.cpp
<![CDATA[
// nuovi elementi: cin.get()
#include <iostream>
using namespace std;
int main() {
char c;
while (cin.get(c))
cout << "[" << c << "]\n";
cout << endl;
}
]]>
a305cget.cpp
<![CDATA[
#include <iostream>
using namespace std;
int main() {
char ch;
int count = 0;
while (cin.get(ch))
if (ch == 'e') ++count;
cout << "La lettera \"e\" e' stata contata " << count << " volte.\n";
}
]]>
a310cput.cpp
<![CDATA[
// nuovi elementi: cout.put(), toupper()
#include <iostream>
using namespace std;
int main() {
char ch, pre = '\n';
while (cin.get(ch)) {
if (pre == ' ' || pre == '\t' || pre == '\n')
cout.put(toupper(ch));
else
cout.put(ch);
pre = ch;
}
}
]]>
a315cing.cpp
<![CDATA[
// nuovi elementi: cin.get() senza parametri
#include <iostream>
using namespace std;
int main() {
char c;
while ((c = cin.get()) != EOF)
cout << c;
cout << endl;
}
]]>
a320eof.cpp
<![CDATA[
#include <iostream>
using namespace std;
int main() {
cout << "EOF = " << EOF << endl;
}
/* Output:
EOF = -1
*/
]]>
a325cing.cpp
<![CDATA[
// nuovi elementi: cin.get() con 2 parametri
#include <iostream>
using namespace std;
int main() {
char buffer[80];
cin.get(buffer,8);
cout << "[" << buffer << "]\n";
cin.get(buffer,sizeof(buffer));
cout << "[" << buffer << "]\n";
}
]]>
a330mani.cpp
<![CDATA[
// nuovi concetti: manipolatori di stream
// nuovi elementi: hex, dec, oct, \t
#include <iostream>
using namespace std;
int main() {
int n = 510;
cout << " \tEsadecimale:\t " << hex << n << "\t " << n
<< "\n\t Decimale:\t " << dec << n << "\t " << n
<< "\n\t Ottale:\t " << oct << n << "\t " << n << endl;
cout << "Introduci un intero in ottale: ";
cin >> oct >> n;
cout << " \tEsadecimale:\t " << hex << n << "\t " << n
<< "\n\t Decimale:\t " << dec << n << "\t " << n
<< "\n\t Ottale:\t " << oct << n << "\t " << n << endl;
cout << "Introduci un intero in esadecimale: ";
cin >> hex >> n;
cout << " \tEsadecimale:\t " << hex << n << "\t " << n
<< "\n\t Decimale:\t " << dec << n << "\t " << n
<< "\n\t Ottale:\t " << oct << n << "\t " << n << endl;
return 0;
}
]]>
a335sqrt.cpp
<![CDATA[
// nuovi elementi: sqrt
#include <iostream>
using namespace std;
int main() {
for (float i=0; i < 10; i++)
cout << '\t' << i << '\t' << sqrt(i) << endl;
return 0;
}
/* Output:
0 0
1 1
2 1.41421
3 1.73205
4 2
5 2.23607
*/
]]>
a340rand.cpp
<![CDATA[
// nuovi elementi: rand
#include <iostream>
#include <iomanip>
using namespace std;
// Questo programma genera dei numeri a caso (random)
int main(){
cout << "\n";
for (int i = 1; i <= 100; i++) {
cout << setw(7) << rand();
if (i&percnt;10 == 0) cout << endl;
}
return 0;
}
]]>
a345rand.cpp
<![CDATA[
// nuovi elementi: RAND_MAX
#include <iostream>
using namespace std;
// Questo programma cerca di valutare l'intervallo dei numeri random
int main() {
int n, min, max;
min = max = n = rand();
for (long i = 2; i <= 100000; i++) {
n = rand();
if (n < min) min = n;
if (n > max) max = n;
}
cout << "\nminimo = " << min << "\nmassimo = " << max << endl;
cout << "\nRAND_MAX = " << RAND_MAX << endl;
return 0;
}
]]>
a350rand.cpp
<![CDATA[
// nuovi elementi: srand, time
#include <iostream>
using namespace std;
int main(){
srand(time(0)); // inizializza il seme per il calcolo dei numeri random
for (int i = 1; i <= 10; i++) {
cout << rand() << endl;
}
cout << endl;
return 0;
}
]]>
a355rand.cpp
<![CDATA[
#include <iostream>
using namespace std;
// Questo programma genera numeri casuali (interi) nell'intervallo [min, max]
int main(){
srand(time(0));
int min, max, quanti, i;
cout << "Introduci minimo e massimo: ";
cin >> min >> max;
int range = max - min + 1;
cout << "Quanti numeri vuoi generare? ";
cin >> quanti;
for (i = 0; i < quanti; i++) {
int r = rand()&percnt;range + min;
cout << r << " ";
}
cout << endl;
return 0;
}
]]>
a360dadi.cpp
<![CDATA[
// Simulazione del lancio di due dadi
#include <iostream>
#include <iomanip>
using namespace std;
int main() {
unsigned long nlanci, i, max, a[11] = {0};
unsigned int j;
srand(time(0));
cout << "Quanti lanci? ";
cin >> nlanci;
for (i=0; i<nlanci; i++)
a[rand()&percnt;6 + rand()&percnt;6]++;
for (max=a[0],i = 1; i < 11; i++)
if (a[i]>max) max=a[i];
cout << "Risultato dei lanci:\n";
for (i = 0; i < 11; i++) {
cout << setw(3) << i+2 << ":" << setw(9) << a[i] << " ";
for (j=1;j<=a[i]*60/max;j++) cout << '*';
cout << endl;
}
cout << " ";
for (j=1;j<=6;j++) cout << "---------+";
cout << endl;
}
]]>
a365sqr.cpp
<![CDATA[
// nuovi concetti: definizione di funzione
#include <iostream>
using namespace std;
// La seguente funzione 'sqr' restituisce il quadrato del suo argomento
int sqr(int n) {
return n * n;
}
int main() {
int i;
for (i=0; i < 6; i++)
cout << '\t' << i << '\t' << sqr(i) << endl;
cout << endl;
return 0;
}
/* Output:
0 0
1 1
2 4
3 9
4 16
5 25
*/
]]>
a370sqr.cpp
<![CDATA[
// nuovi concetti: prototipo di funzione
#include <iostream>
using namespace std;
int sqr(int); // prototipo della funzione 'sqr'
int main() {
for (int i=0; i < 6; i++)
cout << '\t' << i << '\t' << sqr(i) << endl;
cout << endl;
return 0;
}
int sqr(int n) {
return n * n;
}
]]>
a375max.cpp
<![CDATA[
// nuovi concetti: definizione di funzione con piu' parametri e piu' return
#include <iostream>
using namespace std;
int massimo(int, int);
int main(){
int m, n;
do {
cout << "Introduci due interi (0 0 per finire): ";
cin >> m >> n;
if (m || n)
cout << "Il massimo tra " << m << " e " << n << " e' "
<< massimo(m,n) << endl;
} while (m || n);
return 0;
}
int massimo(int x, int y){
if (x < y) return y;
return x;
}
]]>
a380mcd.cpp
<![CDATA[
#include <iostream>
using namespace std;
int mcd(int,int);
int main() {
int a, b;
cout << "----- Massimo Comune Divisore -----\n";
cout << "Introdurre due numeri interi positivi (0 0 per finire):\n";
cin >> a >> b;
while (a > 0 && b > 0) {
cout << "MCD (" << a << "," << b << ") = " << mcd(a,b) << endl;
cin >> a >> b;
}
return 0;
}
int mcd(int a, int b) {
// Calcola il Massimo Comune Divisore (MCD) di a e b
int r;
do {
r = a &percnt; b;
a = b;
b = r;
} while (r > 0);
return a;
}
]]>
a385char.cpp
<![CDATA[
// nuovi concetti: espressione come argomento
// nuovi elementi: void, isdigit(), islower(), ecc...
#include <iostream>
using namespace std;
void printCharCategory(char c, int noprint) {
cout << "Il carattere [";
if (noprint)
cout << "---";
else
cout << c;
cout << "] e' un carattere ";
if (isdigit(c)) cout << "numerico.\n";
else if (islower(c)) cout << "lettera minuscola.\n";
else if (isupper(c)) cout << "lettera maiuscola.\n";
else if (isspace(c)) cout << "di spaziatura.\n";
else if (iscntrl(c)) cout << "di controllo.\n";
else if (ispunct(c)) cout << "d'interpunzione.\n";
else cout << "Errore.\n";
return;
}
int main() {
for (int c = 0; c < 128; c++) {
cout << c << ": ";
printCharCategory(c,c==8||c==10||c==13||c==26);
if (c&percnt;20 == 19)
getchar(); // funziona anche con tasti speciali!
}
return 0;
}
]]>
a390rife.cpp
<![CDATA[
// nuovi concetti: passaggio dei parametri per riferimento
#include <iostream>
using namespace std;
void swap(float & x, float & y) {
float temp = x;
x = y;
y = temp;
}
int main() {
float a = 27, b = -5.041;
cout << a << " " << b << endl;
swap(a,b);
cout << a << " " << b << endl;
return 0;
}
/* Output:
27 -5.041
-5.041 27
*/
]]>
a395fraz.cpp
<![CDATA[
// nuovi elementi: /=, ignore()
#include <iostream>
using namespace std;
void leggi(int&, int&, int&, int&);
int min_com_mul(int, int);
int mas_com_div(int, int);
void semplifica(int&, int&);
void scrivi(int, int);
int main() {
int n1, d1, n2, d2, num, den ;
char c;
do {
leggi(n1,d1,n2,d2);
cout << endl;
cout << n1 << "/" << d1 << " + " << n2 << "/" << d2 << " = ";
den = min_com_mul(d1,d2);
num = den / d1 * n1 + den / d2 * n2;
semplifica(num,den);
scrivi(num,den);
cout << endl << endl;
do {
cout << "Ancora? (S/N)";
c = toupper(cin.get());
cin.ignore(80,'\n');
} while ((c != 'S') && (c != 'N'));
cout << endl << endl;
} while (c == 'S');
cout << "The End!" << endl;
}
void leggi(int& n1, int& d1, int& n2, int& d2) {
do {
cout << "Introduci numeratore e denominatore della prima frazione" << endl;
cout << "diversi da 0 e separati da uno spazio" << endl;
cin >> n1 >> d1;
} while (n1*d1 == 0);
cin.ignore(80,'\n'); // salta (ignora) fino a 80 caratteri o fino al newline
do {
cout << "Introduci numeratore e denominatore della seconda frazione" << endl;
cout << "diversi da 0 e separati da uno spazio" << endl;
cin >> n2 >> d2;
} while (n2*d2 == 0);
cin.ignore(80,'\n');
}
int min_com_mul(int d1, int d2) {
int ma = d1, mb = d2;
while ( ma != mb )
ma > mb ? (mb += d2) : (ma += d1);
return ma;
}
int mas_com_div(int nn, int dd) {
while ( dd ) {
int resto = nn &percnt; dd;
nn = dd;
dd = resto;
}
return nn;
}
void semplifica(int& num, int& den) {
int mcd = mas_com_div(num,den);
num /= mcd;
den /= mcd;
}
void scrivi(int num, int den) {
cout << num;
if ( den != 1 )
cout << "/" << den;
}
]]>
a400para.cpp
<![CDATA[
// nuovi concetti: confronto fra il passaggio dei parametri
// per valore e per riferimento
#include <iostream>
using namespace std;
int n;
void P(int x) {
x += 1;
cout << n << " " << x << " ";
}
void Q(int& x) {
x += 1;
cout << n << " " << x << " ";
}
int main() {
n = 3;
P(n);
cout << n << endl;
n = 3;
Q(n);
cout << n << endl;
}
/* Output:
3 4 3
4 4 4
*/
]]>
a405ambi.cpp
<![CDATA[
// nuovi concetti: ambito degli identificatori
#include <iostream>
using namespace std;
int a, b;
void P(void) {
int a = b+1;
b = a+1;
}
void Q() {
int b = a-1;
a = b-1;
}
int main() {
b = a = 10;
P();
Q();
cout << "a = " << a << ", b = " << b << endl;
}
/* Output:
a = 8, b = 12
*/
]]>
a410scop.cpp
<![CDATA[
// nuovi concetti: visibilita'
#include <iostream>
using namespace std;
int x;
void P1() {
cout << x << endl;
}
void P2() {
int x = 23;
x++;
P1();
}
int main() {
x = 12;
P2();
}
/* Output:
12
*/
]]>
a415visi.cpp
<![CDATA[
// nuovi concetti: variabile globale, ambiti di visibilita'
#include <iostream>
using namespace std;
void f();
void g();
int x = 11;
int main()
{
int x = 22;
{
int x = 33;
cout << "Nel blocco interno a main(): x = " << x << endl;
}
cout << "In main(): x = " << x << endl;
f();
g();
}
void f() {
int x = 44;
cout << "In f(): x = " << x << endl;
}
void g() {
cout << "In g(): x = " << x << endl;
}
/* Output:
Nel blocco interno a main(): x = 33
In main(): x = 22
In f(): x = 44
In g(): x = 11
*/
]]>
a420side.cpp
<![CDATA[
// nuovi concetti: effetti collaterali
// nuovi elementi: *=
#include <iostream>
using namespace std;
int f(int& a) {
a *= 2;
return a;
}
int main() {
int b = 1;
cout << 2*f(b) << " ";
b = 1;
cout << f(b) + f(b) << endl;
}
/* Output:
4 6
*/
]]>
a425prim.cpp
<![CDATA[
// nuovi elementi: bool
//**********************************************************************
//* *
//* Controlla se "n" e' un numero primo (2<=n<=nmax). *
//* *
//**********************************************************************
#include <iostream>
using namespace std;
const int NMAX = 10000;
bool datobuono (int& n, int massimo) {
//*****************************************************************
//* *
//* Ottiene il successivo dato valido, se esiste, saltando *
//* eventuali valori che siano al di fuori dell'intervallo *
//* permesso. Il valore trovato, se c'e', ritorna attraverso *
//* il parametro riferimento "n". Se si preme ^Z, o si *
//* introduce un carattere non accettabile come intero, la *
//* funzione restituisce "falso". Il parametro valore *
//* "massimo" determina l'intervallo accettabile dei dati. *
//* *
//*****************************************************************
bool trovato = false; // abbiamo trovato un "n" valido?
while ( (!trovato) && (cin >> n) )
if ( (n>=2) && (n<=massimo) ) trovato = true;
else cout << n << " fuori limiti: ignorato\n";
return trovato;
} // datobuono
bool decidi (int n) {
//****************************************************************
//* *
//* Determina se "n" e' un numero primo. *
//* Questo sottoprogramma ha un parametro valore; usa due *
//* variabili locali, ma non fa riferimento a nessuna *
//* variabile globale. *
//* *
//****************************************************************
int provadivisore, // possibili divisori di "n"
limite= int(sqrt(float(n))); // il piu' grande divisore possibile di "n"
for (provadivisore = 2; (provadivisore<=limite) && (n &percnt; provadivisore);
provadivisore++);
return (provadivisore > limite);
} // decidi
void mostra (int numero, bool estprimo) {
//***************************************************************
//* *
//* Mostra la decisione del programma ("estprimo") sul *
//* numero corrente. Questo sottoprogramma ha due parametri *
//* valore; non usa variabili locali ne' fa riferimento *
//* a variabili globali *
//* *
//***************************************************************
cout << numero << (estprimo ? "" : " non")
<< " e' un numero primo" << endl;
} // mostra
int main() { // programma principale
int n; // il valore da controllare (dato)
cout << "Controlla se numeri positivi non superiori a " << NMAX
<< " sono primi (^Z per finire):\n\n";
while (datobuono(n,NMAX))
mostra(n,decidi(n));
}
]]>
a430prim.cpp
<![CDATA[
// nuovi concetti: funzione con diversi punti di uscita
#include <iostream>
using namespace std;
int NumeroPrimo(int n) {
float sqrtp = sqrt(float(n));
if (n < 2) return 0;
if (n == 2) return 1;
if (n &percnt; 2 == 0) return 0;
for (int d = 3; d <= sqrtp; d += 2)
if (n &percnt; d == 0) return 0;
return 1;
}
int main() {
for (int n = 1; n < 50; n++)
if (NumeroPrimo(n)) cout << n << " ";
cout << endl;
}
]]>
a435leap.cpp
<![CDATA[
// nuovi concetti: funzione con una sola istruzione (return)
// precedenza degli operatori
#include <iostream>
using namespace std;
bool bisestile(int y) {
return y &percnt; 4 == 0 && (y &percnt; 100 != 0 || y &percnt; 400 == 0);
}
int main() {
int anno;
do {
cout << "Introdurre anno (0 per finire): ";
cin >> anno;
if (anno > 0)
cout << anno
<< (bisestile(anno) ? " " : " non ")
<< "e' un anno bisestile.\n";
} while (anno > 0);
}
]]>
a440retu.cpp
<![CDATA[
// nuovi concetti: while (true) ...
// nuovi elementi: \a (segnale sonoro - beep)
#include <iostream>
using namespace std;
int age(void) {
int n;
while (true) {
cout << "Introdurre l'eta': ";
cin >> n;
if (n < 0) cout << "\a\tL'eta' non puo' essere negativa.";
else if (n > 120) cout << "\a\tL'eta' non puo' essere oltre 120.";
else return n;
cout << "\n\tProva ancora.\n";
}
}
int main() {
int a = age();
cout << "\nL'eta' e' " << a <<" anni.\n";
}
]]>
a445csnt.cpp
<![CDATA[
// nuovi concetti: parametri costanti
#include <iostream>
using namespace std;
void f(int x, int& y, const int z) {
x += z;
y += z;
// z++; // questa istruzione produrrebbe un errore di compilazione!
cout << "x = " << x << ", y = " << y << ", z = " << z << endl;
}
int main() {
int a = 22, b = 33, c = 44;
cout << "a = " << a << ", b = " << b << ", c = " << c << endl;
f(a,b,c);
cout << "a = " << a << ", b = " << b << ", c = " << c << endl;
}
/* Output:
a = 22, b = 33, c = 44
x = 66, y = 77, z = 44
a = 22, b = 77, c = 44
*/
]]>
a450aray.cpp
<![CDATA[
// nuovi concetti: passaggio di array a funzioni
#include <iostream>
using namespace std;
const int size = 100;
void getArray(double [], int&);
void printArray(const double [], const int);
int main() {
double a[size];
int n;
getArray(a,n);
cout << "L'array ha " << n << " elementi.\nQuesti sono:\n";
printArray(a,n);
}
void getArray(double a[], int& n) {
cout << "Introduci i dati. Termina con 0:\n";
for (n = 0; n < size; n++) {
cout << n << ": ";
cin >> a[n];
if (a[n] == 0) break;
}
}
void printArray(const double a[], const int n) {
for (int i = 0; i < n; i++)
cout << '\t' << i << ": " << a[i] << endl;
}
]]>
a455sovr.cpp
<![CDATA[
// nuovi concetti: sovrapposizione di funzioni (function overloading)
#include <iostream>
using namespace std;
int max(int, int);
int max(int, int, int);
double max(double, double);
int main() {
cout << max(99,77) << " " << max(55,66,33) << " " << max(3.4,7.2) << endl;
}
int max(int x, int y) {
return (x > y ? x : y);
}
int max(int x, int y, int z) {
int m = (x > y ? x : y);
return (z > m ? z : m);
}
double max(double x, double y) {
return (x > y ? x : y);
}
/* Output:
99 66 7.2
*/
]]>
a460exit.cpp
<![CDATA[
// nuovi elementi: exit()
#include <iostream>
using namespace std;
double inverso(double x) {
if (x == 0) exit(1);
return 1.0/x;
}
int main() {
double x;
cout << "Introdurre un numero: ";
cin >> x;
cout << "1/" << x << " = " << inverso(x) << endl;
}
]]>
a465dflt.cpp
<![CDATA[
// nuovi concetti: argomenti di default
#include <iostream>
using namespace std;
double p(double, double, double =0, double =0, double =0);
int main() {
double x = 2.0003;
cout << "p(x,7) = " << p(x,7) << endl;
cout << "p(x,7,6) = " << p(x,7,6) << endl;
cout << "p(x,7,6,5) = " << p(x,7,6,5) << endl;
cout << "p(x,7,6,5,4) = " << p(x,7,6,5,4) << endl;
}
double p(double x, double a0, double a1, double a2, double a3) {
return a0 + (a1 + (a2 + a3*x)*x)*x;
}
/* Output:
p(x,7) = 7
p(x,7,6) = 19.0018
p(x,7,6,5) = 39.0078
p(x,7,6,5,4) = 71.0222
*/
]]>
a470peek.cpp
<![CDATA[
// nuovi elementi: cin.peek()
#include <iostream>
using namespace std;
int nextInt();
int main() {
int m = nextInt(), n = nextInt();
cin.ignore(80,'\n');
cout << m << " + " << n << " = " << m+n << endl;
}
int nextInt() {
char ch;
int n = 0;
while ((ch = cin.peek()) != EOF)
if (ch >= '0' && ch <= '9') {
cin >> n;
break;
}
else cin.get(ch);
return n;
}
]]>
a475ofst.cpp
<![CDATA[
// nuovi elementi: <fstream>, ofstream, close
// nuovi concetti: scrittura su file
#include <fstream>
using namespace std;
int main() {
ofstream fout("miofile.txt"); // apro il file
fout << "Ho preso 10 nel quiz e 18 nella prova pratica!" << endl; // scrivo sul file
fout.close(); // chiudo il file
}
]]>
a480ifst.cpp
<![CDATA[
// nuovi elementi: ifstream
// nuovi concetti: lettura da file
#include <iostream>
#include <fstream>
using namespace std;
int main() {
ifstream fin("miofile.txt"); // apro il file
char testo[80];
fin.getline(testo, 80); // leggo una riga dal file
fin.close(); // chiudo il file
cout << testo << endl; // visualizzo la riga letta
}
]]>
a485peek.cpp
<![CDATA[
// nuovi concetti: fin.peek()
#include <iostream>
#include <fstream>
using namespace std;
int nextInt();
ifstream fin("miofile.txt"); // apro il file
int main() {
int m = nextInt(), n = nextInt();
fin.close();
cout << m << " + " << n << " = " << m+n << endl;
}
int nextInt() {
char ch;
int n = 0;
while ((ch = fin.peek()) != EOF)
if (ch >= '0' && ch <= '9') {
fin >> n;
break;
}
else fin.get(ch);
return n;
}
]]>
a490ofst.cpp
<![CDATA[
// nuovi elementi: cerr
#include <iostream>
#include <fstream>
using namespace std;
int main() {
ofstream outfile("voti.dat");
if (!outfile) {
cerr << "Errore: file output non puo' venire aperto.\n";
exit(1);
}
char matricola[9], name[16];
int voto;
cout << "nome matricola voto (^Z per finire)\n";
cout << "\t1: ";
int n = 1;
while (cin >> name >> matricola >> voto) {
outfile << name << " " << matricola << " " << voto << endl;
cout << '\t' << ++n << ": ";
}
outfile.close();
}
]]>
a495ifst.cpp
<![CDATA[
#include <iostream>
#include <fstream>
using namespace std;
int main() {
ifstream infile("voti.dat");
if (!infile) {
cerr << "Errore: file input non puo' venire aperto.\n";
exit(1);
}
char nmatr[9], name[16];
int voto, sum = 0, count = 0;
while (infile >> name >> nmatr >> voto) {
cout << name << "," << nmatr << "," << voto << endl;
sum += voto;
++count;
}
infile.close();
cout << "La votazione media e' " << float(sum)/count << endl;
}
]]>
a500fapp.cpp
<![CDATA[
// nuovi elementi: ios::app
// nuovi concetti: aggiunta a un file
#include <fstream>
using namespace std;
int main() {
ofstream fout("miofile.txt", ios::app);
// il file e' aperto in modalita' append
fout << "Questa e' l'unica riga del file?" << endl;
fout.close();
}
]]>
a505cont.cpp
<![CDATA[
// nuovi concetti: ricorsione
#include <iostream>
using namespace std;
void conta(int n) {
if ( n > 0 ) {
cout << n << " ";
conta(n-1); // chiamata ricorsiva
}
}
int main() {
conta(10);
cout << endl;
}
/* Output:
10 9 8 7 6 5 4 3 2 1
*/
]]>
a510cont.cpp
<![CDATA[
#include <iostream>
using namespace std;
void conta(int n) {
if ( n > 0 ) {
conta(n-1);
cout << n << " ";
}
}
int main() {
conta(10);
cout << endl;
}
/* Output:
1 2 3 4 5 6 7 8 9 10
*/
]]>
a515mcdr.cpp
<![CDATA[
#include <iostream>
using namespace std;
int MCD(int m, int n) {
int r = m &percnt; n;
if (r == 0) return n;
else return MCD(n,r);
}
int main() {
int a, b;
cout << "----- Massimo Comune Divisore -----\n";
cout << "Introdurre due numeri interi positivi (0 0 per finire):\n";
cin >> a >> b;
while (a > 0 && b > 0) {
/* il ciclo termina quando almeno uno dei due numeri e' 0 */
cout << "MCD (" << a << "," << b << ") = " << MCD(a,b) << endl << endl;
cin >> a >> b;
}
}
]]>
a520fact.cpp
<![CDATA[
/* prova di due sottoprogrammi per il calcolo del fattoriale:
uno non ricorsivo, l'altro ricorsivo */
// nuovi elementi: long double
#include <iostream>
using namespace std;
long double fattoriale1 (int n) {
/***********************************************/
/* */
/* Calcola n! per "n" intero positivo. */
/* Questo sottoprogramma e' non ricorsivo */
/* */
/***********************************************/
long double partfact;
for (partfact = 1; n > 1; partfact *= n--)
;
return partfact;
}
long double fattoriale2 (int n) {
/***********************************************/
/* */
/* Calcola n! per "n" intero positivo. */
/* Questo sottoprogramma e' ricorsivo */
/* */
/***********************************************/
return n == 1 ? 1 : n*fattoriale2(n-1);
}
int main() {
int n;
cout << "Calcolo del fattoriale\n";
do {
cout << "Introdurre un numero intero positivo: ";
cin >> n;
if (n>0) {
cout << n << "! calcolato in due modi:" << endl;
cout << fattoriale1(n) << " - non ricorsivo" << endl;
cout << fattoriale2(n) << " - ricorsivo" << endl;
}
} while (n>0);
}
]]>
a525indi.cpp
<![CDATA[
#include <iostream>
using namespace std;
void AllIndietro() {
int numero;
cout << "Dammi un numero (0 per finire): ";
cin >> numero;
if (numero) AllIndietro();
cout << numero << endl;
}
int main() {
AllIndietro();
}
]]>
a530indi.cpp
<![CDATA[
#include <iostream>
using namespace std;
int numero;
void AllIndietro() {
cout << "Dammi un numero (0 per finire): ";
cin >> numero;
if (numero) AllIndietro();
cout << numero << endl;
}
int main() {
AllIndietro();
}
]]>
a535hano.cpp
<![CDATA[
/* Scrive la sequenza richiesta per risolvere il problema */
/* della "Torre di Hanoi" */
#include <iostream>
using namespace std;
unsigned long numeromosse; /* numero di mosse */
void muovidisco (int, int);
void muovitorre (int, int, int);
int main() {
int totale; /* numero di dischi */
cout << "Torre di Hanoi\n";
cout << "Quanti dischi? ";
cin >> totale;
numeromosse = 0;
muovitorre (totale,1,3);
cout << "\nNumero totale mosse per " << totale
<< " dischi = " << numeromosse << endl;
}
void muovitorre (int altezza, int partenza, int arrivo) {
/* Muove una torre di altezza pari ai dischi dalla partenza */
/* all'arrivo */
if (altezza > 0) {
int ausiliario = 6-partenza-arrivo;
muovitorre (altezza - 1,partenza,ausiliario);
muovidisco (partenza,arrivo);
muovitorre (altezza - 1,ausiliario,arrivo);
}
}
void muovidisco (int sorgente, int destinazione) {
/* Scrive e muove da sorgente a destinazione */
numeromosse++;
cout << numeromosse << ": " << sorgente << " -> " << destinazione << endl;
}
]]>
a540bino.cpp
<![CDATA[
/* Coefficienti binomiali o
Triangolo di Pascal o
Triangolo di Tartaglia */
#include <iostream>
#include <iomanip>
using namespace std;
const int NROWS = 10;
int binomial (int n, int k) {
return k==0 || k==n ? 1 : binomial(n-1,k-1) + binomial(n-1,k);
}
int main() {
cout << endl;
for (int i = 0; i < NROWS; i++) {
int j;
for (j = 0; j<(NROWS-i)*3+1; j++) cout << " ";
for (j = 0; j <= i; j++)
cout << setw(6) << binomial(i,j);
cout << endl;
}
}
]]>
a545bina.cpp
<![CDATA[
/****************************************************************************/
/* */
/* Visualizza la rappresentazione in base 2 di un intero "n". */
/* */
/****************************************************************************/
#include <iostream>
using namespace std;
void binary (int n) {
if (n > 0) {
binary(n / 2);
cout << n &percnt; 2;
}
}
int main() {
cout << "Conversione di numeri interi positivi da decimale a binario\n";
cout << "-----------------------------------------------------------\n";
int n;
do {
cout << "Introdurre numero (<=0 per finire): ";
cin >> n;
if (n > 0)
binary(n);
cout << endl;
} while (n > 0);
}
]]>
a550rice.cpp
<![CDATA[
// nuovi concetti: algoritmo di ricerca sequenziale
#include <iostream>
using namespace std;
int main() {
const int n = 10;
int i, x, a[n];
for (i=0; i<n; i++) {
a[i] = rand()&percnt;20; // genera un numero intero a caso tra 0 e 19
cout << a[i] << " ";
}
cout << "\nIntroduci un numero intero: ";
cin >> x;
for (i = 0; i < n && a[i] != x; i++)
// il corpo del for e' vuoto
// se i >= n, l'espressione a[i] != x non viene valutata
;
if (i < n)
cout << "Trovato al posto " << i+1 << endl;
else
cout << "Non trovato" << endl;
}
]]>
a555rice.cpp
<![CDATA[
#include <iostream>
using namespace std;
int main() {
const int n = 10;
int i, x, a[n+1];
for (i=0; i<n; i++) {
cout << (a[i] = rand()&percnt;20) << " ";
}
cout << "\nIntroduci un numero intero: ";
cin >> x;
a[n] = x;
for (i=0; a[i]!=x; i++); // il ciclo termina quando a[i] == x
if (i<n)
cout << "Trovato al posto " << (i+1) << endl;
else
cout << "Non trovato" << endl;
}
]]>
a560rice.cpp
<![CDATA[
// nuovi concetti: algoritmo di ricerca binaria
#include <iostream>
using namespace std;
int main() {
const int n = 200;
int i, max, min, med, x, trovato=0, a[n];
for (i=0; i<n; i++) {
a[i] = i+1;
cout << a[i] << (i&percnt;10 == 9 ? "\n" : " ");
}
cout << "\nIntroduci un numero intero: ";
cin >> x;
max = n-1;
min = 0;
while (!trovato && max>=min) {
med = (max+min)/2;
if (a[med] == x)
trovato = 1;
else if (a[med] > x)
max = med-1;
else min = med+1;
}
if (trovato)
cout << x << " si trova nell'insieme alla posizione " << (med+1) << endl;
else
cout << x << " non si trova nell'insieme" << endl;
}
]]>
a565rice.cpp
<![CDATA[
// nuovi concetti: ricerca binaria ricorsiva
#include <iostream>
using namespace std;
int ricerca (int [], int, int, int, int&);
int main() {
const int N = 1000;
int i, x, pos, a[N];
for (i=0; i<N; i++) {
a[i] = i+1;
cout << a[i] << " ";
}
cout << endl;
cout << "Introdurre un numero intero: ";
cin >> x;
if (ricerca(a,0,N-1,x,pos))
cout << x << " si trova nell'insieme alla posizione " << (pos+1) << endl;
else
cout << x << " non presente nell'insieme!" << endl;
}
int ricerca (int a[], int min, int max, int val, int& pos) {
if (min > max)
return 0;
pos = (max+min) / 2;
if (a[pos] == val)
return 1;
return (a[pos] > val) ? ricerca(a,min,pos-1,val,pos) :
ricerca(a,pos+1,max,val,pos);
}
]]>
a570ordi.cpp
<![CDATA[
// nuovi concetti: algoritmo di ordinamento ingenuo
#include <iostream>
using namespace std;
int main() {
const int n=400;
int i, j, a[n];
srand(time(0));
// Genera array
for (i=0; i<n; i++) a[i]=i+1;
// Mescola gli elementi dell'array
for (i=0; i<n; i++) {
j = rand()&percnt;n;
int t = a[i];
a[i] = a[j];
a[j] = t;
}
// Visualizza array mescolato
for (i=0; i<n; i++)
cout << a[i] << (i&percnt;20 == 19 ? "\n" : " ");
// Ordina array
cout << "\nInizio ordinamento\n";
for (i=0; i<n-1; i++)
for (j=i+1; j<n; j++)
if (a[j] < a[i]) {
int t = a[i];
a[i] = a[j];
a[j] = t;
}
cout << "Fine ordinamento. Premere Invio...\n";
cin.get();
// Visualizza array ordinato
for (i=0; i<n; i++)
cout << a[i] << (i&percnt;20 == 19 ? "\n" : " ");
}
]]>
a575bubl.cpp
<![CDATA[
// nuovi concetti: algoritmo di ordinamento "Bubble Sort"
#include <iostream>
using namespace std;
int main() {
const int n=400;
int i, j, sup, ultimo_scambiato, t, a[n];
srand(time(0));
for (i=0; i<n; i++) a[i]=i+1;
for (i=0; i<n; i++) {
t = a[i];
j = rand()&percnt;n;
a[i] = a[j];
a[j] = t;
}
for (i=0; i<n; i++)
cout << a[i] << (i&percnt;20 == 19 ? "\n" : " ");
cout << "\nInizio ordinamento\n";
sup = n-1;
while (sup >= 0) {
ultimo_scambiato = -1;
for (i=0; i<sup; i++)
if (a[i]>a[i+1]) {
t = a[i];
a[i] = a[i+1];
a[i+1] = t;
ultimo_scambiato = i;
}
sup = ultimo_scambiato;
}
cout << "Fine ordinamento. Premere Invio...\n";
cin.get();
for (i=0; i<n; i++)
cout << a[i] << (i&percnt;20 == 19 ? "\n" : " ");
}
]]>
a580quik.cpp
<![CDATA[
// nuovi concetti: algoritmo "quick sort"
#include <iostream>
using namespace std;
int X[] = {54,6,26,73,1,69,36,70,14,76,81,85,99,8,16,38,45};
int n = sizeof(X)/sizeof(int);
void mostra_sequenza(char intestazione[])
{
cout << "\n" << intestazione;
for (int i = 0; i < n; i++)
cout << " " << X[i];
cout << "\n";
}
void quick_sort(int primo, int ultimo)
{
int temp; // variabile temporanea per lo scambio
if (primo < ultimo)
{
//prendiamo come pivot il primo elemento della sequenza
int pivot = X[primo];
int i = primo;
int j = ultimo;
while (i < j)
{
// cerca, partendo da sinistra, il primo elemento > pivot
while (i < ultimo && X[i] <= pivot)
i++;
// cerca, partendo da destra, il primo elemento < pivot
while (j > primo && X[j] >= pivot)
j--;
if (i < j) //scambio(X[i],X[j])
{
temp = X[i];
X[i] = X[j];
X[j] = temp;
}
}
//scambio(X[j],X[primo])
temp = X[primo];
X[primo] = X[j];
X[j] = temp;
//applico ricorsivamente quick sort alle due parti
quick_sort(primo, j-1);
quick_sort(j+1, ultimo);
}
}
int main(void) {
mostra_sequenza("Sequenza da ordinare:\n");
quick_sort(0,n-1);
mostra_sequenza("Sequenza ordinata con 'quick sort':\n");
}
]]>
a585size.cpp
<![CDATA[
#include <iostream>
using namespace std;
int main() {
cout << "Numero di byte occupati\n";
cout << "\t char: " << sizeof(char) << endl;
cout << "\t short: " << sizeof(short) << endl;
cout << "\t int: " << sizeof(int) << endl;
cout << "\t long: " << sizeof(long) << endl;
cout << "\t unsigned char: " << sizeof(unsigned char) << endl;
cout << "\tunsigned short: " << sizeof(unsigned short) << endl;
cout << "\t unsigned int: " << sizeof(unsigned int) << endl;
cout << "\t unsigned long: " << sizeof(unsigned long) << endl;
cout << "\t signed char: " << sizeof(signed char) << endl;
cout << "\t float: " << sizeof(float) << endl;
cout << "\t double: " << sizeof(double) << endl;
cout << "\t long double: " << sizeof(long double) << endl;
return 0;
}
]]>
a590punt.cpp
<![CDATA[
// nuovi concetti: indirizzo di una variabile
#include <iostream>
using namespace std;
int main() {
int n = 33;
cout << "n = " << n << endl;
cout << "&n = " << &n << endl;
}
/* Output:
n = 33
&n = 0x48172890
*/
]]>
a595alia.cpp
<![CDATA[
// nuovi concetti: riferimento indipendente
#include <iostream>
using namespace std;
int main() {
int n = 33;
int& r = n; // r e' adesso un alias di n
cout << "n = " << n << ", r = " << r << endl;
--n;
cout << "n = " << n << ", r = " << r << endl;
r *= 2;
cout << "n = " << n << ", r = " << r << endl;
}
/* Output:
n = 33, r = 33
n = 32, r = 32
n = 64, r = 64
*/
]]>
a600alia.cpp
<![CDATA[
#include <iostream>
using namespace std;
int main() {
int n = 33;
int& r = n;
cout << "&n = " << &n << ", &r = " << &r << endl;
}
/* Output:
&n = 0x0e272892, &r = 0x0e272892
*/
]]>
a605indi.cpp
<![CDATA[
// nuovi concetti: variabile puntatore
#include <iostream>
using namespace std;
int main() {
int n = 33;
int* p = &n;
cout << "n = " << n << ", &n = " << &n << ", p = " << p << endl;
cout << "&p = " << &p << endl;
}
/* Output:
n = 33, &n = 0x0edf289e, p = 0x0edf289e
&p = 0x0edf289a
*/
]]>
a610inin.cpp
<![CDATA[
#include <iostream>
using namespace std;
int main() {
int n = 33;
int* p = &n;
cout << "*p = " << *p << endl;
}
/* Output:
*p = 33
*/
]]>
a615rife.cpp
<![CDATA[
#include <iostream>
using namespace std;
int main() {
int n = 33;
int* p = &n; // p punta a n
int& r = *p; // r e' un riferimento per n
cout << "r = " << r << endl;
}
/* Output:
r = 33
*/
]]>
a620puar.cpp
<![CDATA[
// nuovi concetti: array come puntatori
#include <iostream>
using namespace std;
int main() {
double a[4] = {22.2, 44.4, 66.6, 88.8};
cout << a << endl;
cout << *a << endl;
cout << *(a+1) << endl;
for (int i = 0; i < 4; i++)
cout << "a[" << i << "] = " << a[i] << endl;
for (int i = 0; i < 4; i++)
cout << "*(a+" << i << ") = " << *(a+i) << endl;
}
/* Output:
0x22ff48
22.2
44.4
a[0] = 22.2
a[1] = 44.4
a[2] = 66.6
a[3] = 88.8
*(a+0) = 22.2
*(a+1) = 44.4
*(a+2) = 66.6
*(a+3) = 88.8
*/
]]>
a625aray.cpp
<![CDATA[
// nuovi concetti: aritmetica dei puntatori
#include <iostream>
using namespace std;
int main() {
short a[] = {22, 33, 44};
int size = sizeof(a) / sizeof(short);
cout << "a = " << a << endl;
cout << "size = " << size << endl;
cout << "sizeof(short) = " << sizeof(short) << endl;
short* end = a + size;
short sum = 0;
for (short* p = a; p < end; p++) {
sum += *p;
cout << "\t p = " << p;
cout << "\t *p = " << *p;
cout << "\t sum = " << sum << endl;
}
cout << "end = " << end << endl;
}
]]>
a630indx.cpp
<![CDATA[
#include <iostream>
using namespace std;
int main() {
short a[] = {22, 33, 44, 55, 66};
cout << "a = " << a << ", *a = " << *a << endl << endl;
for (short* p = a; p < a+5; p++)
cout << "p = " << p << ", *p = " << *p << endl;
}
]]>
a635sequ.cpp
<![CDATA[
#include <iostream>
using namespace std;
short* loc(short* a1, short* a2, int n1, int n2) {
short* end1 = a1 + n1 - n2;
for (short* p1 = a1; p1 <= end1; p1++)
if (*p1 == *a2) {
int j;
for (j = 0; j < n2; j++)
if (p1[j] != a2[j]) break;
if (j == n2) return p1;
}
return NULL;
}
int main() {
short a1[9] = {11, 11, 11, 11, 11, 22, 33, 44, 55};
short a2[5] = {11, 11, 11, 22, 33};
cout << "L'array a1 inizia all'indirizzo \t" << a1 << endl;
cout << "L'array a2 inizia all'indirizzo \t" << a2 << endl;
short* p = loc(a1, a2, 9, 5);
if (p) {
cout << "L'array a2 trovato all'indirizzo \t" << p << endl;
for (int i = 0; i < 5; i++)
cout << '\t' << &p[i] << ": " << p[i]
<< '\t' << &a2[i] << ": " << a2[i] << endl;
}
else cout << "Non trovato.\n";
}
]]>
a640new.cpp
<![CDATA[
// nuovi elementi: new, delete
// nuovi concetti: allocazione dinamica della memoria
#include <iostream>
using namespace std;
int main() {
short * pi = new short; // alloca spazio per uno short int
*pi = 1001; // memorizza un valore in quello spazio
cout << "int: ";
cout << "*pi = " << *pi << ", pi = " << pi << "\n";
cout << "sizeof pi = " << sizeof pi;
cout << ", sizeof *pi = " << sizeof *pi << "\n";
delete pi; // libera lo spazio allocato
double * pd = new double; // alloca spazio per un double
*pd = 10000001.0; // memorizza un valore in quello spazio
cout << "double: ";
cout << "*pd = " << *pd << ", pd = " << pd << "\n";
cout << "sizeof pd = " << sizeof pd;
cout << ", sizeof *pd = " << sizeof *pd << "\n";
delete pd; // libera lo spazio allocato
return 0;
}
]]>
a645ardi.cpp
<![CDATA[
// nuovi concetti: riferimento a puntatore
#include <iostream>
using namespace std;
void get(double*&, int&);
void print(double*, int);
int main() {
double* a;
int n;
get(a,n);
print(a,n);
delete [] a;
get(a,n);
print(a,n);
delete [] a;
}
void get(double*& a, int& n) { // a e' un puntatore passato per riferimento
cout << "Introduci numero di elementi: ";
cin >> n;
a = new double[n];
cout << "Introduci elementi, uno per linea:\n";
for (int i = 0; i < n; i++) {
cout << i+1 << ": ";
cin >> a[i];
}
}
void print(double* a, int n) {
for (int i = 0; i < n; i++)
cout << a[i] << " ";
cout << endl;
}
]]>
a650ordi.cpp
<![CDATA[
#include <iostream>
using namespace std;
void sort(long double [], int);
int main() {
const int n=400;
int i;
long double a[n];
srand(time(0));
for (i=0; i<n; i++) a[i]=i+1;
for (i=0; i<n; i++) {
int j = rand()&percnt;n;
long double t = a[i];
a[i] = a[j];
a[j] = t;
}
for (i=0; i<n; i++)
cout << a[i] << (i&percnt;20 == 19 ? "\n" : " ");
cout << "\nInizio ordinamento\n";
sort(a,n);
cout << "Fine ordinamento. Premere Invio...\n";
cin.get();
for (i=0; i<n; i++)
cout << a[i] << (i&percnt;20 == 19 ? "\n" : " ");
}
void sort(long double a[], int n) {
for (int i=0; i<n-1; i++)
for (int j=i+1; j<n; j++)
if (a[j] < a[i]) {
// sposto long double (12 byte)
long double t = a[i];
a[i] = a[j];
a[j] = t;
}
}
]]>
a655ordi.cpp
<![CDATA[
#include <iostream>
using namespace std;
void sort(long double* [], int);
int main() {
const int n=400;
int i;
long double *a[n];
srand(time(0));
for (i=0; i<n; i++) a[i]=new long double(i+1);
for (i=0; i<n; i++)
cout << *a[i] << (i&percnt;20 == 19 ? "\n" : " ");
cout << "Premere Invio...\n";
cin.get();
for (i=0; i<n; i++) {
int j = rand()&percnt;n;
long double* t = a[i];
a[i] = a[j];
a[j] = t;
}
for (i=0; i<n; i++)
cout << *a[i] << (i&percnt;20 == 19 ? "\n" : " ");
cout << "\nInizio ordinamento\n";
sort(a,n);
cout << "Fine ordinamento. Premere Invio...\n";
cin.get();
for (i=0; i<n; i++)
cout << *a[i] << (i&percnt;20 == 19 ? "\n" : " ");
}
void sort(long double* a[], int n) {
for (int i=0; i<n-1; i++)
for (int j=i+1; j<n; j++)
if (*a[j] < *a[i]) {
// sposto puntatori a long double (4 byte)
long double* t = a[i];
a[i] = a[j];
a[j] = t;
}
}
]]>
a660strn.cpp
<![CDATA[
// nuovi concetti: stringa come puntatore costante a char
#include <iostream>
using namespace std;
int main() {
char animale[] = "cavallo";
char * pesce = "tonno";
cout << animale << ", " << strlen(animale) << endl;
cout << pesce << ", " << strlen(pesce) << endl;
cout << animale[2] << ' ' << *(animale+2) << endl;
cout << pesce[1] << ' ' << *(pesce+1) << endl;
}
]]>
a665inas.cpp
<![CDATA[
// nuovi concetti: inizializzazione di array di stringhe
#include <iostream>
using namespace std;
int main() {
char* name[] = { "George Washington",
"John Adams",
"Thomas Jefferson" };
int dim = sizeof(name)/sizeof(char*);
cout << "I nomi sono:\n";
for (int i = 0; i < dim; i++)
cout << '\t' << i << ". [" << name[i] << "]" << endl;
}
]]>
a670argv.cpp
<![CDATA[
// nuovi elementi: argc, argv
#include <iostream>
using namespace std;
int main(int argc, char* argv[]) {
cout << "Il comando " << argv[0];
if (argc < 2) // ovvero, argc == 1
cout << " non ha argomenti!" << endl;
else {
if (argc == 2)
cout << " ha il seguente argomento:\n";
else // argc > 2
cout << " ha i seguenti " << argc-1 << " argomenti:\n";
for (int i=1; i<argc; i++)
cout << argv[i] << endl;
}
}
]]>
a675piuf.cpp
<![CDATA[
// nuovi elementi: open()
#include <iostream>
#include <fstream>
using namespace std;
int main(int argc, char * argv[]){
if (argc == 1){ // termina se non ci sono argumenti
cerr << "Uso: " << argv[0] << " <nomifile>\n";
exit(1);
}
ifstream fin; // apri stream
long conto;
long totale = 0;
char ch;
for (int file = 1; file < argc; file++) {
fin.open(argv[file]); // connetti stream a argv[file]
if (!fin) {
cerr << "Non sono riuscito ad aprire il file " << argv[file] << "\n";
fin.clear();
continue;
}
for (conto = 0; fin.get(ch); conto++) if (ch=='\n') conto++; // togliere l'if per Unix e Mac
cout << conto << " caratteri in " << argv[file] << "\n";
totale += conto;
fin.close(); // disconnetti file
fin.clear(); // resetto flag EOF
}
cout << totale << " caratteri in totale nei file\n";
return 0;
}
]]>
a680rubr.cpp
<![CDATA[
#include <iostream>
#include <fstream>
using namespace std;
const char * const file = "rubrica.txt";
const int Lun = 40;
void acapo() {
while (cin.get() != '\n')
continue;
}
int main() {
char ch;
ifstream fin(file);
if (fin) {
cout << "Questo e' il contenuto del file " << file << ":\n";
while (fin.get(ch))
cout << ch;
}
fin.close();
ofstream fout(file, ios::app);
if (!fout) {
cerr << "Non e' possibile aprire il file " << file << " in output.\n";
exit(1);
}
char nome[Lun];
do {
cout << "Introdurre un nome (riga vuota per terminare):\n";
cin.get(nome,Lun);
if (nome[0]) {
acapo();
fout << nome << "\t";
cout << "Numero telefonico: ";
cin.get(nome,Lun);
acapo();
fout << nome << "\n";
}
} while (nome[0]);
fout.close();
fin.clear();
fin.open(file);
if (fin) {
cout << "Questo e' il nuovo contenuto del file " << file << ":\n";
while (fin.get(ch))
cout << ch;
}
fin.close();
}
]]>
a685fstr.cpp
<![CDATA[
// nuovi elementi: fstream, ios::in, ios::out, ios::binary, |, seekp(), ios::cur
// nuovi concetti: lettura-scrittura su file
// ATTENZIONE: ACCERTARSI CHE I FILE FORNITI COME ARGOMENTO POSSANO ESSERE MODIFICATI
#include <iostream>
#include <fstream>
using namespace std;
int main(int argc, char* argv[]) {
if (argc < 2) {
cout << "Bisogna fornire il nome di un file (modificabile) come argomento!" << endl;
exit(1);
}
fstream iofile(argv[1], ios::in | ios::out | ios::binary);
if (!iofile) {
cerr << "Errore: file in/out non puo' venire aperto.\n";
exit(2);
}
else {
cout << "Il file " << argv[1] << " esiste gia': posso modificarlo? (s/N)";
char ch = toupper(cin.get());
if (ch != 'S') exit(3);
}
cout << "\nSto modificando il file " << argv[1] << ".....\n";
char c;
while (iofile.get(c))
if (islower(c)) {
iofile.seekp(-1, ios::cur); // torna indietro di un byte
c = toupper(c);
iofile.put(c);
iofile.seekg(0, ios::cur); // curiosamente, senza questa istruzione non funziona!
}
iofile.close();
cout << "Il file " << argv[1] << " e' stato modificato!" << endl;
}
]]>
a690strc.cpp
<![CDATA[
// nuovi elementi: strchr(), strrchr(), strstr()
// nuovi concetti: localizzazione di caratteri e sottostringhe
// all'interno di una stringa
#include <iostream>
using namespace std;
int main() {
char s[] = "The Mississippi is a long river.";
cout << "s = \"" << s << "\"\n";
char* p = strchr(s,' ');
cout << "strchr(s,' ') punta a s[" << p-s << "].\n";
p = strchr(s,'s');
cout << "strchr(s,'s') punta a s[" << p-s << "].\n";
p = strrchr(s,'s');
cout << "strrchr(s,'s') punta a s[" << p-s << "].\n";
p = strstr(s,"is");
cout << "strstr(s,\"is\") punta a s[" << p-s << "].\n";
p = strstr(s,"isi");
if (p == NULL) cout << "strstr(s,\"isi\") restituisce NULL\n";
}
]]>
a695stok.cpp
<![CDATA[
// nuovi concetti: isolare le parole da una frase
// nuovi elementi: strtok()
#include <iostream>
using namespace std;
int main() {
char s[] = "Today's date is March 12, 1995.";
char* p;
cout << "La stringa e': [" << s << "]\nI token sono:\n";
p = strtok(s," ");
while (p) {
cout << "\t[" << p << "]\n";
p = strtok(NULL, " ");
}
cout << "Ora la stringa e': [" << s << "]\n";
}
]]>
a700cplx.cpp
<![CDATA[
// nuovi elementi: struct
#include <iostream>
using namespace std;
struct Complesso {
float re, im;
};
void leggi (Complesso& c) {
cout << " parte reale: ";
cin >> c.re;
cout << " parte immag: ";
cin >> c.im;
}
void scrivi (Complesso c) {
cout << c.re << " ";
if (c.im)
if (c.im > 0)
cout << " +i" << c.im;
else
cout << " -i" << -c.im;
cout << endl;
}
Complesso add (Complesso c1, Complesso c2) {
Complesso sum;
sum.re = c1.re + c2.re;
sum.im = c1.im + c2.im;
return sum;
}
Complesso sub (Complesso c1, Complesso c2) {
Complesso diff;
diff.re = c1.re - c2.re;
diff.im = c1.im - c2.im;
return diff;
}
Complesso mul (Complesso c1, Complesso c2) {
Complesso prod;
prod.re = c1.re * c2.re - c1.im * c2.im;
prod.im = c1.re * c2.im + c1.im * c2.re;
return prod;
}
float modquad (Complesso c) {
return c.re * c.re + c.im * c.im;
}
Complesso divi (Complesso c1, Complesso c2) {
Complesso divis;
float m = modquad(c2);
divis.re = ( c1.re * c2.re + c1.im * c2.im) / m;
divis.im = ( c1.im * c2.re - c1.re * c2.im) / m;
return divis;
}
int main() {
Complesso a, b;
cout << "Operazioni elementari con numeri complessi\n\n";
cout << "primo numero\n";
leggi(a);
cout << "secondo numero\n";
leggi(b);
cout << "\nprimo numero = ";
scrivi(a);
cout << "secondo numero = ";
scrivi(b);
cout << "somma = ";
scrivi(add(a,b));
cout << "sottrazione = ";
scrivi(sub(a,b));
cout << "moltiplicazione = ";
scrivi(mul(a,b));
cout << "divisione = ";
if (modquad(b))
scrivi(divi(a,b));
else
cout << " divisione per zero\n";
}
]]>
a705cplx.cpp
<![CDATA[
// nuovi concetti: incapsulamento, metodi, metodi inline
#include <iostream>
using namespace std;
struct Complesso {
float re, im;
void leggi();
void scrivi();
Complesso add(Complesso);
Complesso sub(Complesso);
Complesso mul(Complesso);
Complesso divi(Complesso);
float modquad() {return re * re + im * im;}
};
void Complesso::leggi() {
cout << " parte reale: ";
cin >> re;
cout << " parte immag: ";
cin >> im;
}
void Complesso::scrivi() {
cout << re << " ";
if (im)
if (im > 0)
cout << " +i" << im;
else
cout << " -i" << -im;
cout << endl;
}
Complesso Complesso::add (Complesso c) {
Complesso sum;
sum.re = re + c.re;
sum.im = im + c.im;
return sum;
}
Complesso Complesso::sub (Complesso c) {
Complesso diff;
diff.re = re - c.re;
diff.im = im - c.im;
return diff;
}
Complesso Complesso::mul (Complesso c) {
Complesso prod;
prod.re = re * c.re - im * c.im;
prod.im = re * c.im + im * c.re;
return prod;
}
Complesso Complesso::divi (Complesso c) {
Complesso divis;
float m = c.modquad();
divis.re = ( re * c.re + im * c.im) / m;
divis.im = ( im * c.re - re * c.im) / m;
return divis;
}
int main() {
Complesso a, b;
cout << "Operazioni elementari con numeri complessi\n\n";
cout << "primo numero\n";
a.leggi();
cout << "secondo numero\n";
b.leggi();
cout << endl;
cout << "primo numero = ";
a.scrivi();
cout << "secondo numero = ";
b.scrivi();
cout << "somma = ";
a.add(b).scrivi();
cout << "sottrazione = ";
a.sub(b).scrivi();
cout << "moltiplicazione = ";
a.mul(b).scrivi();
cout << "divisione = ";
if (b.modquad())
a.divi(b).scrivi();
else
cout << " divisione per zero" << endl;
}
]]>
a710read.cpp
<![CDATA[
// nuovi elementi: cin.read()
#include <iostream>
using namespace std;
int main() {
char buffer[] = "????????????????????";
cin.read(buffer,8);
cout << "[" << buffer << "]" << endl;
cin.read(buffer,4);
cout << "[" << buffer << "]" << endl;
}
]]>
a715writ.cpp
<![CDATA[
// nuovi elementi: cout.write()
#include <iostream>
using namespace std;
int main() {
cout.write("ABCDEFGHIJKLMNOPQRSTUVWXYZ", 8);
cout << endl;
char * stringa = "0123456789";
cout.write(stringa,4);
cout << endl;
}
]]>
a720binf.cpp
<![CDATA[
// nuovi elementi: ios::binary, clear()
// nuovi concetti: file binario
#include <iostream>
#include <fstream>
#include <iomanip>
using namespace std;
void acapo() {
while (cin.get() != '\n') continue;
}
struct tfilm {
char titolo[36]; // titolo del film
char regista[22]; // nome del regista
short int anno; // anno di uscita
float valutazione; // valutazione del film
};
void contenuto(ifstream&);
const char * const file = "films.dat";
int main() {
// cout.setf(ios::showpoint);
cout.setf(ios::fixed, ios::floatfield);
cout << setprecision(1);
// mostra il contenuto iniziale
ifstream fin;
fin.open(file, ios::in | ios::binary); // file binario
if (fin) {
cout << "Il contenuto del file "
<< file << " e' il seguente:\n";
contenuto(fin);
}
fin.close();
// aggiungi altri dati
ofstream fout(file, ios::out | ios::app | ios::binary);
if (!fout) {
cerr << "Non riesco ad aprire il file " << file << " in scrittura!\n";
exit(1);
}
tfilm film;
cout << "Introdurre il titolo del film (<Invio> per terminare):\n";
cin.get(film.titolo, 36);
while (film.titolo[0] != '\0') {
acapo();
cout << "Regista: ";
cin.get(film.regista,22);
acapo();
cout << "Anno: ";
cin >> film.anno;
cout << "Valutazione (0-10): ";
cin >> film.valutazione;
fout.write((char *) &film, sizeof film);
acapo();
cout << "Introdurre il titolo del film"
" (<Invio> per terminare):\n";
cin.get(film.titolo, 36);
}
fout.close();
// mostra il file modificato
// fin.clear(); // probabilmente serve col Dev C++
fin.open(file, ios::in | ios::binary);
if (fin) {
cout << "Il seguente e' il contenuto del file " << file
<< " dopo l'aggiornamento:\n";
contenuto(fin);
}
fin.close();
return 0;
}
void contenuto(ifstream& file)
{
tfilm film;
while (file.read((char *) &film, sizeof film)) {
cout.setf(ios::left, ios::adjustfield);
cout << setw(30) << film.titolo << ": "
<< setw(20) << film.regista;
cout.setf(ios::right, ios::adjustfield);
cout << setw(8) << film.anno
<< setw(8) << film.valutazione << "\n";
}
}
]]>
a725dump.cpp
<![CDATA[
// nuovi elementi: fill(), isgraph()
#include <iostream>
#include <fstream>
#include <iomanip>
using namespace std;
/* dump esadecimale e ASCII di un file */
int main(int argc, char * argv[]) {
if (argc == 1){ // termina se non ci sono argumenti
cerr << "Uso: " << argv[0] << " <nomefile>\n";
exit(1);
}
char b;
unsigned short a;
int c=0, r=0;
unsigned int ind=0;
char riga[17] = " "; // 16 spazi
ifstream fin(argv[1]);
if (!fin) {
cerr << "Non sono riuscito ad aprire il file " << argv[1] << "\n";
exit(2);
}
cout.fill('0');
cout << " " << hex << setw(4) << ind << " ";
while (fin.get(b)) {
(a=b) &= 0xFF; // converto b in numero e ne prendo gli 8 bit meno significativi
ind++;
cout << " " << setw(2) << a;
riga[c] = isgraph(b) ? b : ' ';
if (++c==8) cout << " ";
else if (c==16) {
cout << " " << riga << endl;
c=0;
if (++r==16) {
cin.get();
cout << endl;
r=0;
}
if (fin.peek() != EOF)
cout << " " << setw(4) << ind << " ";
}
}
fin.close();
if (c<16) {
for (r=c; r < 16; r++) {
cout << " ";
riga[r] = ' ';
}
if (c<8) cout << " ";
cout << " " << riga << endl;
}
return 0;
}
]]>
a730dstr.cpp
<![CDATA[
#include <iostream>
#include <fstream>
using namespace std;
int main(int argc, char * argv[]) {
if (argc == 1) // termina se non ci sono argumenti
{
cerr << "Uso: " << argv[0] << " <nomefile>\n";
exit(1);
}
ifstream fin(argv[1]);
if (!fin)
{
cerr << "Non sono riuscito ad aprire il file " << argv[1] << "\n";
exit(2);
}
char riga[80];
char * righe[1000];
int n;
for (n=0; fin.getline(riga,80); n++) {
righe[n] = new char[strlen(riga)+1];
strcpy(righe[n],riga);
}
fin.close();
for (n--;n>=0;n--) {
cout << righe[n] << endl;
delete [] righe[n];
}
}
]]>
a735invl.cpp
<![CDATA[
// nuovi elementi: operatore freccia ( -> )
// nuovi concetti: lista dinamica
#include <iostream>
using namespace std;
struct Lnodo {
char dato;
Lnodo *succ;
};
int main () {
Lnodo *base=NULL, *p;
cout << "Introdurre una sequenza di caratteri (^Z per terminare):" << endl;
char ch;
while (cin.get(ch)) {
p = new Lnodo;
p->dato = ch; // p->dato equivale a (*p).dato
p->succ = base;
base = p;
}
while (p) {
cout << p->dato;
base = p;
p = p->succ;
delete base;
}
}
]]>
a740invl.cpp
<![CDATA[
#include <iostream>
using namespace std;
struct Lnodo {
char dato;
Lnodo *succ;
};
void MostraLista(Lnodo*);
int main () {
Lnodo *base=NULL, *p;
cout << "Introdurre una sequenza di caratteri (^Z per terminare):" << endl;
char ch;
while (cin.get(ch)) {
p = new Lnodo;
p->dato = ch;
p->succ = base;
base = p;
}
MostraLista(base);
}
void MostraLista(Lnodo* lista) {
while (lista) {
cout << lista->dato;
lista = lista->succ;
}
}
]]>
a745invl.cpp
<![CDATA[
// nuovi concetti: liste e ricorsione
#include <iostream>
using namespace std;
struct Lnodo {
char dato;
Lnodo *succ;
};
void MostraLista(Lnodo*);
int main () {
Lnodo *base=NULL, *p;
cout << "Introdurre una sequenza di caratteri (^Z per terminare):" << endl;
char ch;
while (cin.get(ch)) {
p = new Lnodo;
p->dato = ch;
p->succ = base;
base = p;
}
MostraLista(base);
}
void MostraLista(Lnodo* lista) {
if (lista) {
cout << lista->dato;
MostraLista(lista->succ);
}
}
]]>
a750copl.cpp
<![CDATA[
#include <iostream>
using namespace std;
struct Lnodo {
char dato;
Lnodo *succ;
};
void AggiungiNodo(Lnodo*&);
void MostraLista(Lnodo*);
void DistruggiLista(Lnodo*&);
int main () {
Lnodo *base;
cout << "Introdurre una sequenza di caratteri (^Z per terminare):" << endl;
base = NULL;
while (cin.peek() != EOF)
AggiungiNodo(base);
MostraLista(base);
DistruggiLista(base);
}
void AggiungiNodo(Lnodo*& lista) {
if (lista)
AggiungiNodo(lista->succ);
else {
lista = new Lnodo;
lista->succ = NULL;
cin.get(lista->dato);
}
}
void MostraLista(Lnodo* lista) {
if (lista) {
cout << lista->dato;
MostraLista(lista->succ);
}
}
void DistruggiLista(Lnodo*& testa) {
if (testa) {
DistruggiLista(testa->succ);
delete testa;
}
}
]]>
a752list.cpp
<![CDATA[
// nuovi concetti: manipolazione di liste
// parametro stream
#include <iostream>
#include <fstream>
using namespace std;
struct Lnodo {
int dato;
Lnodo *succ;
};
void writelist(Lnodo*);
void InserisciPrima(Lnodo*&, Lnodo*, Lnodo*);
void InserisciDopo(Lnodo*&, Lnodo*, Lnodo*);
void InvertiLista(Lnodo*&);
bool ListeUguali(Lnodo*, Lnodo*);
void LeggiInTesta(ifstream&, Lnodo*&);
void LeggiInCoda(ifstream&, Lnodo*&);
void DistruggiLista(Lnodo*&);
int main () {
Lnodo *lista1=NULL, *lista2=NULL;
ifstream fin("lista.txt");
cout << "\nDati letti dal file:\n";
LeggiInTesta(fin,lista1);
cout << "Dati come inseriti nella lista N. 1:\n";
writelist(lista1);
fin.clear();
fin.seekg(0);
cout << "\nDati letti dal file:\n";
LeggiInCoda(fin,lista2);
fin.close();
cout << "Dati come inseriti nella lista N. 2:\n";
writelist(lista2);
InvertiLista(lista2);
cout << "\nContenuto della lista N. 2 rovesciata:" << endl;
writelist(lista2);
if (ListeUguali(lista1,lista2))
cout << "OK";
else
cout << "Oh Oh...!!!";
cout << endl;
DistruggiLista(lista2);
DistruggiLista(lista1);
}
void writelist(Lnodo* ptr) {
while (ptr) {
cout << ptr->dato << " ";
ptr = ptr->succ;
}
cout << endl;
}
void InserisciPrima(Lnodo* &testa, Lnodo* posto, Lnodo* nuovo) {
// Inserisce il nodo 'nuovo' nella lista 'testa' prima di 'posto'
if (testa == NULL) {
nuovo->succ = NULL;
testa = nuovo;
}
else if (posto==testa) {
nuovo->succ = testa;
testa = nuovo;
}
else {
Lnodo* precedente;
for(precedente=testa;precedente->succ!=posto;precedente=precedente->succ)
continue;
nuovo->succ = posto;
precedente->succ = nuovo;
}
}
void InserisciDopo(Lnodo* &testa, Lnodo* posto, Lnodo* nuovo) {
// Inserisce il nodo 'nuovo' nella lista 'testa' dopo 'posto'
if (testa == NULL) {
nuovo->succ = NULL;
testa = nuovo;
}
else {
nuovo->succ = posto->succ;
posto->succ = nuovo;
}
}
void InvertiLista(Lnodo*& testa) {
// Inverte la lista 'testa' (il nodo di coda diventa il nodo di testa e viceversa)
Lnodo *prima=NULL, *corrente=testa, *dopo;
while (corrente) {
dopo = corrente->succ;
corrente->succ = prima;
prima = corrente;
corrente = dopo;
}
testa = prima;
}
bool ListeUguali(Lnodo* l1, Lnodo* l2) {
// Restituisce true se le due liste sono uguali, cioe'
// se le due liste sono entrambe vuote, oppure
// il contenuto della testa coincide e le liste private della testa
// sono uguali
return (!(l1 || l2) ||
l1 && l2 && l1->dato==l2->dato &&
ListeUguali(l1->succ,l2->succ));
}
void LeggiInTesta(ifstream& fin, Lnodo*& testa) {
int n;
Lnodo *ptr;
testa = NULL;
while (fin >> n) {
ptr = new Lnodo;
ptr->dato = n;
cout << n << " ";
InserisciPrima(testa, testa, ptr);
}
cout << endl;
}
void LeggiInCoda(ifstream& fin, Lnodo*& testa) {
int n;
Lnodo *ptr, *ultimo;
testa = NULL;
while (fin >> n) {
ptr = new Lnodo;
ptr->dato = n;
cout << n << " ";
InserisciDopo(testa, ultimo, ptr);
ultimo = ptr;
}
cout << endl;
}
void DistruggiLista(Lnodo*& testa) {
while (testa) {
Lnodo* ptr = testa;
testa = testa->succ;
delete ptr;
}
}
]]>
a755albe.cpp
<![CDATA[
#include <iostream>
#include <fstream>
using namespace std;
typedef int Tipo;
struct Tnodo
{
Tipo info;
Tnodo *sin, *des;
};
void inserisci(Tnodo*&, Tnodo*);
void InOrdine(Tnodo*);
void EliminaAlbero(Tnodo*&);
int main () {
Tnodo *albero=NULL, *ptr;
ifstream fin("lista.txt");
cout << "\nDati letti dal file:\n";
Tipo n;
while (fin >> n) {
cout << n << " ";
ptr = new Tnodo;
ptr->info = n;
ptr->sin = ptr->des = NULL;
inserisci(albero,ptr);
}
fin.close();
cout << "\nVisita InOrdine:\n";
InOrdine(albero);
EliminaAlbero(albero);
return 0;
}
void inserisci(Tnodo*& radice, Tnodo* elemento) {
if (radice)
if (radice->info >= elemento->info)
inserisci(radice->sin,elemento);
else
inserisci(radice->des,elemento);
else
radice = elemento;
}
void InOrdine(Tnodo* radice) {
if (radice) {
InOrdine(radice->sin);
cout << radice->info << endl;
InOrdine(radice->des);
}
}
void EliminaAlbero(Tnodo*& radice) {
if (radice) {
EliminaAlbero(radice->sin);
EliminaAlbero(radice->des);
delete radice;
}
}
]]>