C++, manuale minimo Relazionali:

< minore
Ripetizione
Ciclo while:
<= minore o uguale
1. Tipi standard > maggiore
numeri interi short, int, long >= maggiore o uguale
while{condizione}
numeri reali float, double, long double == uguale
istruzione;
carattere char != non uguale Funzionamento:
booleana bool Logici:
1 Si valuta condizione: se è vero si va al punto 2
Esempio:
|| disgiunzione (OR)
altrimenti al punto 3.
&& congiunzione (AND)
2 Si esegue istruzione (che può essere composta da più
int x; // dichiara x senza inizializzarla ! negazione (NOT)
istruzioni) e si torna al punto 1.
int y=10; // dichiara y e la inizializza a 10 Incremento e decremento:
3 Il ciclo termina.
char a='x'; // dichiara a e la inizializza a x ++ incremento
double b; // dichiara b senza inizializzarla -- decremento Esempio:

float c=1.1; // dichiara c e la inizializza a 1.1 Gli operatori ++ e -- si possono usare in maniera post (prima int i=2,s=0;
si utilizza il valore e si modica il valore dopo) e pre (prima si while(i<=20){
Array monodimensionale (statico) modica il valore e dopo si utilizza il valore già modicato). s+=i;
Gli array contengono più variabili dello stesso tipo. L'indice Esempio:
i+=2;}
del primo elemento è 0. Dichiarazione: // s e' la somma dei numeri pari fra 2 e 20 (inclusi)
int x=4,y=5,z; cout << s << endl;
tipo nome[dimensione]; z=x+y; // assegna x+y a z
cout << z << endl; // stampa 9 Ciclo do-while:
Esempio: z+=x; // assegna z+x a z
int x[5]; // dichiara un array di 5 int cout << z << endl; // stampa 13 do
double y[10]; // dichiara un array di 10 double cout << z%x << endl; // stampa 1 istruzione;
long z[]={12,34}; // dichiara un array di 2 long cout << (z<y) << endl; // stampa 0 (falso) while{condizione};
// inizializzate a 12 e 34 cout << (z>y) << endl; // stampa 1 (vero)
cout << z[0] << endl; // stampa 12 cout << (z>y&&z>x) << endl; //stampa 1 (vero) Funzionamento:

cout << (z>y&&x>y) << endl; //stampa 0 (falso) 1 Si esegue istruzione (che può essere composta da più
cout << z[1] << endl; // stampa 34
cout << (z>y||x>y) << endl; //stampa 1 (vero) istruzioni) e si va al punto 2.

cout << x++ << endl; // stampa 4 e incrementa x 2 Si valuta condizione: se è vero si va al punto 1
Array multidimensionale (statico) cout << x << endl; // stampa 5 altrimenti al punto 3.
Gli array multidimensionali sono array di array. Dichiarazione: cout << ++x << endl; // incrementa x e stampa x (6) 3 Il ciclo termina.

Esempio:
tipo nome[dim_1][dim_2]...[dim_n];
3. Strutture di controllo int i=2,s=0;
Esempio: do{
int x[2][3]; // matrice con 2 righe e 3 colonne Selezione s+=i;
x[1][2]=10; // setta l'elemento nella 2. riga e i+=2;}while(i<=20);
Se condizione è vero allora si esegue istruzione_1 (che può // s e' la somma dei numeri pari fra 2 e 20 (inclusi)
//nella 3. colonna a 10 essere composta da più istruzioni) altrimenti istruzione_2 cout << s << endl;
(che può essere composta da più istruzioni):

2. Operatori comuni Ciclo for:

if(condizione)
Assegnamento:
istruzione_1;
= assegna la destra alla sinistra
else for(inizializzazione;condizione;aggiornamento)
+= combinazione di somma e assegnamento
istruzione_2; istruzione;
*= combinazione di prodotto e assegnamento
-= combinazione di sottrazione e assegnamento Funzionamento:

/= combinazione di divisione e assegnamento Esempio: 1 Si esegue inizializzazione (che può essere composta
Aritmetica: da più istruzioni separate da ,) e si va la punto 2.
+ somma int a,b; 2 Si valuta condizione: se è vero si va al punto 3
* prodotto cin >> a >> b; altrimenti al punto 5.
- sottrazione if(a>b) 3 Si esegue istruzione (che può essere composta da più
/ divisione cout << a << " e' maggiore di " << b; istruzioni) e si va al punto 4.
% resto di divisione intera else 4 Si esegue aggiornamento (che può essere composta da
(La divisione 7/5 restituisce 1 mentre la divisione 7./5 cout << a << " non e' maggiore di " << b; più istruzioni separate da ,) e si torna al punto 2.
restituisce 1.4.) 5 Il ciclo termina.
Esempio: return true; // utilizzo di read_vet e sum_vet
} int *v1,n1;
int i,s;
v1=read_vet(n1);
for(i=2,s=0;i<=20;i+=2) Possibile utilizzo della funzione precedente:
cout << "Somma: " << sum_vet(v1,n1) << endl;
s+=i;
double c2,c1,c0,r1,r2; delete[] v1; // dealloca
// s e' la somma dei numeri pari fra 2 e 20 (inclusi)
cout << s << endl; cin >> c2 >> c1 >> c0;
if(zeri(c2,c1,c0,r1,r2)) 6. Struttura di un semplice programma
cout << r1 << " " << r2 << endl;
4. Funzioni Un semplice programma può essere scritto in un singolo le
con estensione .cpp. Il programma comincia con gli #include
Le funzioni possono prendere parametri e possono restituire
5. Puntatori delle librerie e le dichiarazioni globali (costanti, variabili e
valori. Forma generale:
I puntatori rappresentano la posizione (indirizzo di memoria) using). Il resto del programma è un elenco di funzioni. Deve
tipo_restituito nome(tipo_1 parametro_1,..., di variabili. Per dichiarare un puntatore si utilizza *: esserci una funzione main dove comincia l'esecuzione del
tipo_n parametro_n){ programma. Per poter usare una funzione prima di denirla
...} short *x; // dichiara un puntatore a short completamente bisogna specicare il suo prototipo.
double *y; // dichiara un puntatore a double
#include<iostream> // input-output
Passaggio di parametro per valore L'operatore & restituisce l'indirizzo di una variabile.
#include<cmath> // funzioni matematiche
I parametri di default vengono passati con passaggio di L'operatore * restituisce il valore che si trova ad un certo
// exp, log, log10, pow, sqrt, ceil, floor, round, abs
indirizzo.
parametro per valore. #include<cstdlib> // numeri casuali
Esempio: Esempio: #include<ctime> // per misurare tempo
Funzione che restituisce il maggiore fra due interi:
int x1=10,x2; #include<iomanip> // formato output
int maggiore(int a, int b){ int *p1;
p1=&x1; // p1 punta a x1 using namespace std; // per abbreviare
if(a>b) return a;
return b; x2=*p1; // il valore puntato da p1 viene
// assegnato a x2 // prototipi delle funzioni
} bool zeri(double, double, double, double &, double &);
cout << x2 << endl; // stampa 10
Possibile utilizzo della funzione precedente:
*p1=15; // viene assegnato 15 alla variabile int maggiore(int, int);
int e=10,f=100; // puntata da p1 (cioe' a x1)
cout << x1 << endl; // stampa 15 // modulo principale
cout << maggiore(e,f) << endl; int main() {
Funzione che stampa il minore fra due numeri reali: double c2,c1,c0,r1,r2;
Allocazione dinamica della memoria (array cin >> c2 >> c1 >> c0;
void minore(double a, double b){ dinamici) if(zeri(c2,c1,c0,r1,r2))
if(a<b) cout << a << endl; I puntatori si usano per allocare memoria in maniera dinamica cout << setprecision(5) << r1 << " " << r2 << endl;
cout << b << endl; (la quantità di memoria utilizzata viene stabilita run-time).
} Per allocare memoria si usa new, per deallocare delete. Una int e,f;
Possibile utilizzo della funzione precedente: volta allocata la memoria, si accede agli elementi come se si cin >> e >> f;
trattasse di un array statico. cout << maggiore(e,f) << endl;
double e=1.1,f=2.2;
Esempio:
minore(e,f); return 0;
// legge un vettore di interi }
Passaggio di parametro per riferimento int* read_vet(int &n){
Aggiungendo & si può eettuare passaggio di parametro per cin >> n; // numero di elementi int maggiore(int a, int b){
valore. Questo permette di restituire più di un valore. int *v=new int[n]; // alloca memoria if(a>b) return a;
for(int i=0;i<n;i++) return b;
Esempio:
cin >> v[i]; }
Funzione che calcola i zeri di un polinomio di secondo grado se
return v; // restituisce l'indirizzo degli interi
essi sono numeri reali (restituisce true se i zeri sono numeri
} bool zeri(double a, double b, double c,
reali e i zeri stessi vengono restituiti tramite il quarto e il
quinto parametro della funzione):
double &z1, double &z2){
// calcola la somma di un vettore di interi double d=b*b-4*a*c;
bool zeri(double a, double b, double c, int sum_vet(int *v, int n){ if(d<0) return false;
double &z1, double &z2){ int s=0; d=sqrt(d);
double d=b*b-4*a*c; for(int i=0;i<n;i++) z1=(-b-d)/2/a;
if(d<0) return false; s+=v[i]; z2=(-b+d)/2/a;
d=sqrt(d); return s; return true;
z1=(-b-d)/2/a; } }
z2=(-b+d)/2/a;