/* my program in C++
with few comments */
#include <iostream>
using namespace std;
int main ()
{
cout << "Hello World! "; // prints Hello World!
cout << "I'm a C++ program"; // prints I'm a C++ program
return 0;
}
--------------------Compilazione
g++ file.cpp
--------------------Variable identifiers
var
Var
var1
var2
var_new
var_2
--------------------Tipi di dati
char 1 byte
wchar_t 4 byte
int intero di 4 byte (sistemi a 32 bit)
float floating point in singola precisione (4 byte)
double floating point in doppia precisione (8 byte)
long double floating point in doppia precisione (16 byte)
short int 2 byte
long int 8 byte
bool valore booleano true o false
l'operatore sizeof consente di sapere la dimensione in byte
di un tipo o di una variabile:
a = sizeof (char); // il risultato e' 1
--------------------Variable declaration
le variabili globali vengono dichiarate al di fuori della
funzione main() mentre le variabili locali sono dichiarate
all'interno di un blocco e sono valide dal punto in cui
sono dichiarate fino alla fine del blocco {}
int a, b, c;
double result;
le variabili possono essere inizializzate al momento della dichiarazione:
int a = 0;
int a(0);
--------------------Strings
per usare le variabili di tipo stringa
occore il seguente header file:
#include <string>
string mystring;
mystring = "testo di una stringa di caratteri";
--------------------Costanti
75 costante int
75l costante long int
3.1415 costante double
3e-9 costante double
3.1e8 costante double
3.2l costante long double
3.2f costante float
true costante booleana
false costante booleana
'a' costante singolo carattere
"word" costante stringa
"stringa definita \
su due righe" costante stringa
l"wide characters string" costante stringa composta di wchar_t
alcuni caratteri speciali:
'\0' null
'\a' campanello
'\b' backspace
'\n' new line
'\t' tab
'\r' return
'\\' backslash
'\'' apice
'\"' virgolette "
'\xhh' carattere indicato in esadecimale
costanti definite dalla direttiva al preprocessore:
#define PI 3.14159
#define NEWLINE '\n'
dichiarazione di costanti di tipo definito:
const int pathwidth = 100;
const char tabulator = '\t';
--------------------Operatori aritmetici e assignment
+ - * / operatori aritmetici
% operatore modulo, riporta il resto intero di una divisione
a = 5*(2+b);
assegna il right value alla variabile a (left value)
a -= 2; equivale ad a = a-2;
a /= 3; equivale ad a = a/b;
++a equivale ad a = a+1;
a++ come il precedente, ma l'incremento avviene dopo il calcolo dell'intera espressione
--------------------Operatori relazionali
== != > < >= <=
confrontano due espressioni, il risultato e' un valore booleano (true o false)
2+2 >= 5 (false)
2+2 == 4 (true)
--------------------Operatori logici
! && ||
combina espressioni booleane e quindi il suo risultato sara' true o false
(2+2)>3 && (3+3)<4 il risultato e' false
!false il risultato e' true
--------------------Type casting operator
converte nel tipo posto tra parentesi:
int i;
float f = 3.14;
i = (int) f;
--------------------Input output
#include <iostream>
#include <string>
#include <sstream>
cout << "Hello" << endl; // standard output
cin >> a; // standard input
usando l'operatore di estrazione (>>) sullo stream cin
si possono fornire sequenze di dati, ciascuno per ogni variabile,
separati da un blank separator (space, tab, newline), purche'
la variabile sia definita del tipo giusto (int, double)
In alternativa si puo' leggere una intera linea come stringa di caratteri
string mystr;
getline (cin, mystr); // legge la stringa nello standard input
string mystr = "1204";
int myint;
stringstream(mystr) >> myint; // converte la stringa in uno stream
string mystr;
int price;
getline (cin, mystr);
stringstream(mystr) >> price; // converte la stringa in uno stream
// legge il primo dato fino allo spazio
--------------------Input output con file
#include <iostream>
#include <string>
#include <fstream>
ofstream myfile; // crea un file come stream e inserisce una linea
myfile.open ("file.txt");
myfile << "Writing this to a file.\n";
myfile.close ();
string line; // legge da un file una linea alla volta
ifstream myfile;
myfile.open ("example.txt");
if (myfile.is_open())
{
while ( getline (myfile,line) )
{
cout << line << endl;
}
myfile.close();
}
--------------------Strutture di controllo
if (condizione) { // block
statement1;
statement2;
}
else if {
}
else {
}
while (condizione) {
}
do {
} while (condizione);
for (int n=10; n>0; n--) {
}
for (n=10; n>0; n--) {
cout << n << ", ";
if (n==3) {
cout << "countdown aborted!";
break; // uso del break per uscire dal loop
}
}
for (int n=10; n>0; n--) {
if (n==5) continue; // uso di continue per saltare una iterazione
cout << n << ", ";
}
switch (expression)
{
case constant1:
group of statements 1;
break;
case constant2:
group of statements 2;
break;
default:
default group of statements
}
--------------------Funzioni
type name (type par1, type par2, ...); //declaration of function prototype
type name (type par1, type par2, ...) { //argomenti per valore
statements;
return ();
}
void name (type& par1, type& par2, ...) { //argomenti per reference
statements;
return 0;
}
--------------------Array
int arr[5];
int arr[3][3];
int arr[] = {1, 2, 3, 4, 5}; //inizializzazione
arr[0] = 8; //accesso al primo elemento
arr[2][2] = 8;
sequenze di caratteri:
char myword [] = { 'H', 'e', 'l', 'l', 'o', '\0' };
char myword [] = "Hello";
string mystring;
mystring = myword; //trasformazione in stringa
--------------------Pointers
int var;
int * mypointer; //declaration of poiter to int variable
mypointer = &var; //address of var
*mypointer = 10; //value poited by mypointer
--------------------Data structures
struct frutta { //dichiarazione di una struttura
int weight; //membri della struttura
float price;
};
frutta mela; //type declaration "frutta"
frutta banana;
mela.price //utilizzo di un membro della struttura
frutta * pbanana;
pbanana = &banana;
pbanana->price; //utilizzo di un puntatore alla struttura
--------------------Altri data types
typedef int word; //definisce sinonimi di data types esistenti
enum enumeration_name { //crea un nuovo data type
value1,
value2,
value3
};
enum colore_t {rosso, giallo, verde};
colore_t mycolor;
mycolor = rosso;
--------------------Classi
class class_name {
private: //default, members accessibili solo da members della classe
member1;
public: //members accessibili da tutti
member2;
protected: //members accessibili da members della stessa classe o classi derivate
member3; //i class members possono essere dichiarazioni di dati o funzioni
};
class CRectangle {
int x, y;
public:
void set_values (int a, int b){
x = a;
y = b;
}
int area () {return (x*y);}
};
class CRectangle {
int x, y;
public:
void set_values (int,int);
int area () {return (x*y);}
};
void CRectangle::set_values (int a, int b) {
x = a; // operator of scope :: used to define
y = b; // a member of a class from outside the
} // class definition itself
class CRectangle {
int width, height;
public:
CRectangle (int,int);
int area () {return (width*height);}
};
CRectangle::CRectangle (int a, int b) { //constructor: funzione usata
width = a; //per inizializzare le variabili
height = b;
}
CRectangle rect (3,4); //il constructor viene chiamato quando si crea un oggetto della classe