Linguaggio C++

     

Ogni programma C++ deve possedere una funzione principale,chiamata main(),contenente le istruzioni da eseguire.

int main(){
cout<<”Temp.[C]=”;
cin>>c; cout<<”Temp.[F]=”<<c*9/5+32;
return 0;
}

La parola chiave int davanti a main() indica che il valore ritornato (in questo caso 0) è un intero.

Identificatori

     

Gli identificatori sono nomi che consentono l'individuazione delle entità presenti in un programma C++.

Un identificatore può contenere solo caratteri dell'alfabeto inglese (minuscoli e maiuscoli ), le 10 cifre decimali e il carattere underscore _ .
Non sono consentiti spazi ed altri caratteri. L' identificatore deve iniziare con una lettera o con il carattere underscore.

Il C++ distingue le lettere minuscole da quelle maiuscole (è case sensitive ).
Identificatori con lo stesso nome,ma con il formato di una o più lettere diverso, sono distinti;per esempio: l'identificatore Dato è considerato diverso dall' identificatore dato.

Variabili e costanti simboliche

     

Servono per memorizzare dei valori.
Le variabili consentono la modifica del loro valore durante l'esecuzione del programma, le costanti non lo cosentono .

Variabili

     

Le variabili di un programma devono possedere un nome, un tipo e un valore. Prima di essere utilizzate vanno dichiarate.
Esempi:
int K;
double x =1.2345;

La seconda riga,oltre a dichiarare la variabile x, di tipo double, la inizializza con il valore 1.2345.

Tipi fondamentali

     

I tipi fondamentali sono:
● char, per i caratteri;
● bool, per le espressioni booleane;
● int ,short, long, long long (signed e unsigned), per gli interi;
● float,double,long double,per i numeri reali.

Il tipo char

     

Le variabili di tipo char servono a contenere caratteri stampabili (per esempio 'a', 'X', '1', '*') e, solitamente, occupano 1 byte di memoria.
Ogni carattere è rappresentato internamente con un codice numerico. La codifica più usata è quella ASCII.

Il tipo int

     

Il tipo int serve a memorizzare numeri interi compresi in un intervallo che dipende dall'implementazione del compilatore.
In quelle dove un int è rappresentato internamente con 16 bit (2 byte), l'intervallo è:

-32768 ÷ 32767

Con 32 bit (4 byte), invece, i valori memorizzabili sono:

-2147483648 ÷ 2147483647

I tipi short, long e long long

     

Le variabili di tipo short si impiegano quando si desidera memorizzare delle quantità intere nel minore spazio di memoria possibile.
Solitamente occupano 16 bit, e possono pertanto rappresentare numeri interi compresi nell'intervallo:

-32768 ÷ 32767

Una variabile di tipo long, invece, generalmente occupa 32 bit e serve a rappresentare numeri interi più grandi.
Il tipo long long serve a memorizzare grandi quantità d'interi e, di solito, occupa 64 bit

-9223372036854775808 ÷ 9223372036854775807

Il tipo unsigned

     

La parola chiave unsigned, anteposta ai tipi interi fondamentali (int, short, long e long long), specifica che le corrispondenti variabili possono memorizzare solo valori positivi:
Esempi:

Una variabile di tipo unsigned short può memorizzare valori: 0 ÷ 65535 se di tipo unsigned long, invece: 0 ÷ 4294967295 .

Tipi reali: float, double e long double

     

Le variabili di tipo reale possono contenere valori appartenenti a un sottoinsieme dei numeri reali.
A seconda della precisione desiderata, è possibile scegliere tra i seguenti tipi:
● float 6-7 cifre
● double 15-16 cifre
● long double 18-19 cifre

Costanti letterali

     

I valori costanti impiegati in un programma sono spesso chiamati letterali (o costanti senza nome). Possono essere di tipi:
● costanti carattere (singoli caratteri);
● costanti stringa (sequenze di caratteri);
● costanti booleane;
● costanti numeriche intere;
● costanti numeriche reali .

Costanti carattere

     

Vengono rappresentate racchiudendo fra apici il corrispondente carattere esempi: '*', '3' .
L'ultima costante rappresenta il carattere stampabile 3 e non il valore decimale 3.
I caratteri non stampabili (caratteri di controllo) possono essere rappresentati da combinazioni speciali dette sequenze di escape.
Una sequenza di escape inizia con una barra rovesciata (backslash, \) anche chiamata slash retroverso.

Sequenze di escape

     

Costanti stringa

     

Una costante stringa è costituita da una sequenza di caratteri racchiusa tra una coppia di virgolette (" ").
Esempio:    "Spazio di frenata: "

In una costante stringa possono essere presenti anche delle sequenze di escape.
Esempio : "\aCalcolo spazio di frenata\n"

Due costanti stringhe separate da "spazi bianchi" equivalgono a una sola costante stringa.

Esempio:

"\aCalcolo spazio"
"di frenata\n"

equivale alla costante stringa dell'esempio precedente.

Spazi bianchi

     

Sono caratteri che si chiamano così perché hanno lo stesso scopo degli spazi bianchi dei testi su carta stampata, ovvero servono a separare gli elementi e le righe di un programma.

Esempi:
● spazi;
● tabulazioni;
● caratteri di ritorno a capo.

Costanti booleane

     

Esistono solo due costanti di questo tipo: true e false; possono essere impiegate per assegnare dei valori a variabili di tipo bool.

Esempio: bool oK=false;

Costanti numeriche intere

     

Le costanti numeriche intere sono rappresentate da una sequenza di cifre, che vengono interpretate.
● in base ottale se iniziano con zero;
● in base esadecimale se iniziano con 0x (oppure 0X);
● in base decimale negli altri casi (default) .

Esempi:
1234 costante ottale
0x12ABF costante esadecimale
658973 costante decimale

La rappresentazione interna di una costante numerica intera dipende dal suo valore. Il compilatore utilizzerà automaticamente il tipo più adatto .
E' possibile definire una costante di tipo long facendo seguire dalla lettera L.
Se seguita da LL è interpretata come long long.
12345678L //long
1234567812345678LL //long long

Costanti numeriche reali

     

Una costante numerica reale (in virgola mobile) viene rappresentata facendo uso del punto decimale e della lettera e (oppure E) per separare la parte in virgola fissa dall'esponente.
Esempio: 12.3456e2 equivale a 1234.56
Le costanti numeriche reali sono memorizzate come double, ma è possibile modificare questo comportamento predefinito facendo seguire le cifre numeriche dal suffisso F o da suffisso L.
Nel primo caso la costante sarà memorizzata come float nel secondo come un long double.

Costanti simboliche

     

Per rendere più leggibile un programma, nelle espressioni è possibile sostituire le costanti letterali (o senza nome) con nomi simbolici. L'associazione nome-valore avviene con una sintassi molto simile a quella impiegata per dichiarare le variabili:

const tipo identificatore = exp;

La parola chiave const non permette che il valore di identificatore possa essere modificato da altre istruzioni del programma. exp può essere un valore oppure un'espressione il cui valore deve poter essere calcolato in fase di compilazione.
Dopo questa dichiarazione , identificatore può essere impiegato ovunque sia possibile usare il letterale corrispondente.
Esempio:
#include<iostream>
using namespace std;
main(){
  const double pi =3.1415;
  const double _2pi= 2 * pi;
  float r=1,c;
  c= _2pi * r;
  cout<<c;
}

Espressioni operandi e operatori

     

Le espressioni sono combinazioni di operandi e operatori. Gli operandi sono i valori che intervengono nel calcolo e possono essere rappresentati da nomi di variabili e costanti. Gli operatori sono caratteri e loro combinazioni che servono a indicare quale tipo di calcolo va eseguito.
+ · - · * · / · % · ^ · & · | · ~ ·
! · = · < · > · += · - = · * = · /= · %=·
^=· &=·|=·<<·>>·>>=·<<=·==·!=·<=·>=·&&·||·++·--·,·->*·->·.*·::·()·[]·?:

Priorità degli operatori

     

Ogni operatore è caratterizzato dalle seguenti priorità :
● numero di operandi ( o parità);
● posizione rispetto ai suoi operandi.
Un operatore si dice :
● prefisso se precede gli argomenti;
● suffisso se segue gli argomenti;
● infisso se sta fra gli argomenti;

● Precedenza (o priorità) nell'ordine di esecuzione delle operazioni.
Per esempio, l'espressione 65+37/5 viene calcolato come 65+(37/5) e non come (65+37)/5;
● Associatività,ovvero l'ordine in cui vengono eseguiti i calcoli nel caso di operatori con la stessa priorità.
Gli operatori possono essere associativi a destra o a sinistra .

Operatori aritmetici

     

Se gli operandi sono entrambi interi il risultato della divisione sarà intero e gli eventuali decimali saranno eliminati (troncamento).
Tra gli operatori aritmetici è compreso anche l'operatore resto% che calcola il resto della divisione tra due operandi interi.

Operatori di incremento e decremento unitario

     

Sono operatori che hanno un solo operando. L'operatore di incremento aumenta di un'unità il valore del suo operando. È rappresentato da due segni + ravvicinati(++). L'operatore di decremento, indicato con due segni- consecutivi (--), diminuisce di un'unità il valore del suo operando.
La valutazione dell'espressione dove appaiono cambia in funzione della loro posizione rispetto all'operando: se lo precedono si parla di operatori prefissi, se lo seguono di operatori suffissi ( o postfissi).

Operatori sui bit

     

 

Si suppongano a e b due interi unsigned di 8 bit

a 00001011
b 00001110
allora
a>>2   0000001011
a<<2 0000101100
a & b  00001010
a | b  00001111
a ^ b  00000101
~a     11110100

Operatori di assegnazione

     

Sintassi :    exp1=exp2

exp1 deve riferirsi ad una locazione di memoria modificabile, exp2 è il valore che sarà scritto in quella locazione.

int i;
i=1;

Il valore dell'espressione dopo l'assegnazione è quello di exp2.
Poiché l'operatore = è associativo a destra, exp2 può essere a sua volta un'espressione di assegnazione.

int i, j, k;
i=(j=(k=100));

Le parentesi non sono necessarie, ma possono servire a chiarire l'ordine delle operazioni.

Operatori di assegnazione composti

     

Sono operatori costituiti da un operatore aritmetico oppure bit a bit e da un operatore di assegnazione.

Tra i due simboli che costituiscono un operatore di assegnazione composto non deve esserci alcuno "spazio bianco".

Operatore sizeof

     

E' valutato in fase di compilazione e restituisce un intero che rappresenta la dimensione in byte, del suo operando. Si può applicare a variabili, costanti e tipi.

Esempi:

sizeof i ;
sizeof "Il Linguaggio C++";
sizeof (double) ;

Le parentesi sono obbligatorie solo se sizeof è applicato a un tipo.

Conversioni di tipo

     

Se in un'espressione si usano operandi di tipo diverso, come per esempio:

int d= 10;
double pi = 3.14159, c;
c = d * pi;

è sempre necessaria una conversione di tipo, che può essere implicita o esplicita.

Conversioni implicite

     

Vengono realizzate in fase di compilazione. Gli operandi numerici sono convertiti nel tipo dell'operando di dimensione maggiore. Per esempio, nella moltiplicazione:

10 * 3.14159

Il numero 10 (int) è implicitamente convertito in 10.0, ovvero nel tipo dell'operando di dimensione maggiore, 3.14159 (double). Solo a quel punto viene effettuata la moltiplicazione. L'operazione di assegnazione costituisce un'eccezione a questa regola. Il tipo dell'operando di sinistra:

int k;
k = 3.14159

Dopo l'operazione di assegnazione nella variabile k (int) si troverà il valore 3.

Conversioni esplicite (casting)

     

int IVA=20;
double p=156.32, totale;
totale=p*(1+IVA/100);

L'espressione IVA/100 darà come risultato 0 perché entrambi gli operandi sono interi.
Il problema si risolve richiedendo la conversione esplicita (casting) di uno dei due operandi in double.

totale=p*(1+(double)IVA/100);

Adesso il valore del secondo operando è 100.0, pertanto IVA sarà semplicemente convertito in double e il risultato della divisione sarà coretto.
Una sintassi alternativa è la seguente :

tot = p*(1+double(IVA)/100);

Stream

     

Uno stream (flusso) è un canale virtuale mediante il quale un programma comunica con l'esterno. Può essere pensato come una struttura logica costituita da una sequenza di caratteri che fluiscono da una periferica di input verso il programma (stream d'ingresso) oppure dal programma verso una periferica di output (stream d'uscita). Per funzionare ogni stream deve essere associato alla corrispondente periferica fisica (tastiera, video, stampante ecc.). In C++ esistono degli stream standard, ovvero già associati alle corrispondenti periferiche fisiche:

● cin (ingresso: tastiera);
● cout (uscita: video);
● cerr (errore: video);
● clog (errore: video).

Per utilizzare questi stream occorre impiegare oggetti e funzioni presenti in un'apposita libreria di ingresso/uscita. A questo fine, nel programma sorgente bisogna inserire la direttiva:

#include <iostream>

Stream di ingresso

     

Lo stream di ingresso standard, cin , è quello da cui il programma legge i dati, ed è tipicamente associato alla tastiera. Per prelevare i dati si usa la seguente sintassi:

cin >> variabile;

L'operatore di estrazione >> preleva dallo stream i caratteri battuti sulla tastiera prima di invio e li converte nel tipo di variabile. Da uno stream di ingresso è possibile leggere anche piu di un dato :

cin >>i>>d>>c;

se i,d e c sono tre variabili, rispettivamente di tipo int, double e char e sulla tastiera si batte la sequenza di caratteri 123 456.78 k, al termine di questa istruzione i, d e c conterranno rispettivamente i valori: 123, 456.78 e 'k'.

Stream di uscita

     

Lo stream di uscita standard, cout, è quello su cui il programma scrive i dati, ed è tipicamente associato allo schermo. Per scrivere dati si usa la seguente sintassi:

cout << espressione;

L'operatore di inserzione << converte il valore di espressione in una sequenza di caratteri che viene inviata sullo schermo. espressione è un insieme di operandi e operatori, o più semplicemente una variabile o una costante.
Mediante lo stream cout è possibile inviare allo schermo anche più lavori contemporaneamente :

cout<< "Valore:" <<x<<endl;

In questo caso saranno visualizzati la stringa costante e il valore della variabile x. Il manipolatore endl produce sullo schermo gli stessi effetti della sequenza di escape '\n', ovvero un ritorno a capo

Commenti

     

I commenti servono a documentare un programma sorgente e sono considerati come "spazi bianchi" dal compilatore. I caratteri che costituiscono un commento possono essere racchiusi fra le coppie di caratteri /* e */ o tra la coppia // e la fine della riga.

Esempi:

/* Questo commento può occupare più righe */
// Questo commento solo una