Short introduction to most popular programming languages

1. C/C++/JAVA Refresh rapido

2. Cominciamo col C

3. Struttura di un programma C /* This is a comment */ // This is a one-line comment # include <stdio.h> /* includes header files */ main() /* Must have a main function. First function { printf (&quot;Hello World!&quot;); /* stdio functions */ }

8. Funzioni e prototipi #include <stdio.h> int add1(int); void main() { int x; x=5; x=add1(x); printf(&quot;%d“,x); } int add1(int i) { int y; y=i+1; return (y); }

10. Tabella di “verità”

11. Esempio shifting

13. Array int x[10]; double y[15]; x[10]=10; char c[15];

14. Puntatori!!! int a, *b, c; // b is a pointer b = &a; // Store in b the address of a c = *b; // Store in c the value at // address b (i.e., a)

15. Puntatori a caratteri e array char *y; char x[100]; y = &x[0]; y = x; // Does the same as the line above *(y+1) gives x[1] *(y+i) gives x[i]

16. Ancora puntatori int x,y; int *p1,*p2; 1000 1004 1008 1012 x y p1 p2

17. Ancora puntatori(2) x=-42; y=163 1000 1004 1008 1012 x y p1 p2 -42 163

18. Ancora puntatori(3) p1=&x; p2=&y; 1000 1004 1008 1012 x y p1 p2 -42 163 1000 1004

19. Ancora puntatori(4) *p1=17; 1000 1004 1008 1012 x y p1 p2 17 163 1000 1004

20. Ancora puntatori(5) p1=p2; 1000 1004 1008 1012 x y p1 p2 17 163 1000 1004

22. Strutture struct emprec { char name[25]; int age; int pay; }; struct emprec employee; employee.age=32;

24. Introduzione al C++ e alla programmazione ad oggetti

26. Il rapporto Dato-Algoritmo Linguaggio Bits Bits macchina Programmazione Dati Algoritmi Livello di astrazione Assemblers Symbolic Op-code Words Compilatori Variables & Statements Types Linguaggi Data Subroutines strutturati structures Ada (Modula) Abstract Packages Data Types (Modules) Object Oriented Objects Objects

28. Un esempio...

29. Soldato

46. Tipi predefiniti in C++ (2) 123 123 0x123 interi costanti , decimale, ottale, esadecimale 123l 123u interi, long, unsigned ‘ A’ ‘1’ ‘’ caratteri, tab 3.14f 3.1415 3.1415L float, double, long double 300e-2 .03e2 30e-1 double, notazione esponenziale “ Nome” stringa costante true false boolean Esempi di costanti ‘ ’ alert ‘ ’ backslash ‘ ’ backspace ‘ ’ carriage return ‘ ’ double quote ‘ ’ form feed ‘ ’ tab ‘ ’ newline ‘ ’ carattere nullo ‘ ’ single quote ‘ ’ vertical tab ‘ 01’ 101 ottale, ‘A’ ‘ 041’ esadecimale, ‘A’ Costanti carattere “” stringa nulla (‘’) “ nome” ‘n’ ‘o’ ‘m’ ‘e’ ‘’ “ una stringa” stampa: una “stringa” “ una stringa un alla fine della linea su piu` linee” per continuare la stringa Stringhe costanti

47. Tipi predefiniti in C++ (3) char [1] int [1] bool short [1] long [1] float double long double 8 16 16 16 32 32 64 64 8 32 32 16 32 32 64 128 8 32 32 16 64 32 64 128 OS 16 bit OS 32 bit OS 64 bit [1] Può essere unsigned

58. Operatori -i +w piu` e meno unari a*b a/b i%2 moltiplicazione, divisione, modulo a+b a-b addizione e sottrazione binarie a=3; assegnazione Espressioni Aritmetiche Commento k = ++j; j=j+1; k=j; k = j++; k=j; j=j+1; k = --j; j=j-1; k=j; k = j--; k=j; j=j-1; Auto-incremento Espressione e decremento ~i; Complemento bit a bit i&j; AND bit a bit i|j OR bit a bit i^j XOR bit a bit i<<n shift a sinistra di n pos. i>>n shift a destra di n pos. bit-wise significato < minore di .LT. > maggiore di .GT. <= minore o uguale .LE. >= maggiore o uguale .GE. == uguale .EQ. != diverso .NE. ! Negazione unaria .NOT. && and logico .AND. || or logico .OR. Operatori relazionali Fortran

60. Statements vuoto ; espressione j=j+k; composto { . . . . } usato in funzioni, if.. Costituisce un blocco goto goto label; da non usarsi if if (p==0) cerr<<“error”; un solo branch if-else if (x==y) cout<<“the same”; else cout<<“different”; due branch for for (j=0;j<n;j++) le dichiarazioni sono a[j]=0; permesse while while (i != j) 0 o piu` iterazioni i++; do-while do y=y-1; 1 o piu` iterazioni while (y>0); break break; esce dal blocco continue continue; prossima iterazione Statement C++ commenti

61. Statements (2) switch switch (s) { case 1: si deve usare break per ++i; evitare di cadere nei case 2: casi successivi e --i; aggiungere un caso di default: default alla fine della ++j; lista }; dichiarazione int i=7; in un blocco, file o namespace try try {. . . .} usato per trattare le eccezioni label error: cerr<<“Error!”; usato con goto return return x*x*x; valore di ritorno di una funzione Statement C++ commenti

85. Funzioni (2) funzione double cube(double x) parametri passati { return x*x*x; } “by value” procedura void pr_square(int i) subroutine, non si { cout<<i*I<<endl; } usa return senza argomenti void hello () puo` anche essere { cout<<“Hello”<<endl; } void hello(void) argomenti passati void swap(int& i,int& j) i e j hanno i loro per riferimento { int t=i; i=j; j=t; } valori scambiati variabile int scanf(const char, … ) chiamata con un qualsiasi numero di argomenti inline inline double cube(int x) codice inline argomenti di int power(int i, int n=2) il 2do argomento default puo` essere tralasciato Tipo di dichiarazione C++ commenti

100. Una classe C++ Messaggio Messaggio Messaggio Metodo Metodo Metodo Attributo Attributo Attributo

116. Un contatore Class MyClass { private: static int counter; static void increment_counter() { counter++; } static void decrement_counter() { counter--; } public: MyClass() { increment_counter(); } ~MyClass() { decrement_counter(); } static int HowMany() { return counter; } }; #include <iostream.h> #include “MyClass.h” int MyClass::counter=0; int main() { MyClass a,b,c; MyClass *p=new MyClass; cout<<“ How many? “<< MyClass::HowMany() <<endl; delete p; cout<<“ and now? “<< a.HowMany() <<endl; return 0; } Un membro statico deve essere inizializzato una e una sola volta nel codice eseguibile Un metodo statico puo` essere invocato cosi`... … o cosi`...

130. Un esempio: lo stack di interi ... Lo stack vuoto class Contenuto { ... private: Contenuto* next; int val; }; class Stack { ... private: Contenuto* top; }; val Contenuto next val Contenuto next val Contenuto next Stack top Stack top

131. Un esempio: lo stack di interi class Stack { public: Stack() {top = 0;} ~Stack() {} void push ( int i ) { Contenuto* tmp = new Contenuto(i,top ); top = tmp; } int pop () { int ret = top->getVal(); Contenuto* tmp = top; top = top->getNext(); delete tmp; return ret; } private: Contenuto* top; }; class Contenuto { public: Contenuto ( int i, Contenuto* ptn ) { val=i; next=ptn; } int getVal (){ return val; } Contenuto* getNext() {return next;} private: Contenuto* next; int val; }; int main() { Stack s; s.push ( 10 ); s.push ( 20 ); cout << s.pop() << “ - “ << s.pop; return 0; }; User code >> 10 - 20 Output

132. Lo stack “templato” template <class T > class Stack { public: Stack() {top = NULL;} ~Stack() {;} void push ( T i ) { Contenuto<T>* tmp = new Contenuto<T> (i,top ); top = tmp; } T pop () { T ret = top->getVal(); Contenuto<T>* tmp = top; top = top->getNext(); delete tmp; return ret; } private: Contenuto<T>* top; }; template <class T > class Contenuto { public: Contenuto ( T i, Contenuto* ptn ) { val = i; next = ptn; } T getVal (){ return val; } Contenuto* getNext() {return next;} private: Contenuto* next; T val; }; int main() { Stack<int> s; s.push ( 10 ); s.push ( 20 ); Stack<double> s1; Stack<Shape *> s2; cout << s.pop() << “ “ << s.pop; return 0;}; User code

141. Esempio uso sequenze #include < > #include <algorithm> #include <iostream> int main() { <int> container; int val; for (int i=0; i<10; i++) { val = (int)((float)rand()/RAND_MAX*10); container.push_back(val); } <int>::iterator it1; for ( it1= container.begin(); it1!= container.end(); it1++) cout << &quot;vector : &quot; << *it1 << endl; return 0; } vector vector vector list list list

142. Esempio uso contenitori associativi #include <map> #include <algorithm> #include <iostream> #include <string> int main() { map<string,int> amap ; amap[&quot;Primo”]=1; amap[“Secondo”]=2; cout << &quot;Size : &quot; << amap.size() << endl; amap[&quot;Terzo&quot;]=3; amap[&quot;Quarto&quot;]=4; cout << &quot;Size : &quot; << amap.size() << endl; map<string,int>::iterator it; for ( it= amap.begin(); it!= amap.end(); it++) cout << &quot;map : &quot; << it->first << &quot; &quot; << it->second << endl; cout << amap.find(&quot;Terzo&quot;)-> second << endl; return 0; }

145. Typing & Binding Typing Definizione dei messaggi e degli argomenti Binding Assegnazione di un metodo ad un messaggio Strong Consistenza dei tipi verificata dal compilatore Weak Consistenza dei tipi verificata a run-time Early In fase di programmazione INFLESSIBILE Late A run-time POLIMORFISMO

158. Cerchi e quadrati Quadrato Cerchio

159. Cerchio public: Circle (Point2d center, double radius); ~Circle (); void moveAt (const Point2d & p); void moveBy (const Point2d & p); void scale (double s); void rotate (double phi); void draw () const; void cancel () const; class Circle { }; private: Point2d center_; double radius_; Circle.h Costruttore Distruttore Nome della classe Punto e virgola ! Point2d : classe che rappresenta un punto in 2 dimensioni. “ Dati” privati ( Attributi , membri) Interfaccia Pubblica Metodi : operazioni sugli oggetti

160. Cerchio (2) # include “Circle.h” void Circle :: draw () const { const int numberOfPoints = 100; float x[numberOfPoints], y[numberOfPoints]; float phi = 0, deltaPhi = 2*M_PI/100; for ( int i = 0; i < numberOfPoints; ++i ) { x[i] = center_.x() + radius_ * cos( phi ); y[i] = center_.y() + radius_ * sin( phi ); phi += dphi; } polyline_draw (x, y, numberOfPoints, color_, FILL); } void Circle :: moveAt ( const Point2d& p ) { cancel (); center_ = p; draw (); } void Circle :: scale ( double s ) { cancel (); radius_ *= s; draw (); } Circle :: Circle ( Point2d c, double r ) : center_( c ), radius_( r ) { draw (); } Circle :: ~Circle () { cancel (); } Circle.cc #include “Circle.h” int main() { Circle c ( Point2d(10, 10), 5 ); c . draw (); c . moveAt (Point2d(20, 30)); return 0; } Main.cc

161. Quadrato upperCorner loweCorner centerToUpperCorner _ class Square { public: Square (const Point2d&, const Point2d&, Color color = TRASPARENT); ~Square (); void moveAt ( const Point2d& p ); void moveBy ( const Point2d& p ); void changeColor ( Color color ); void scale ( double s ); void rotate ( double phi ); void draw () const; void cancel () const; private: Point2d center_; Vector2d centerToUpperCorner_; Color color_; }; Square.h #include “Square.h” void Square :: draw () const { float x[4], y[4]; Vector2d delta( centerToUpperCorner_ ); for ( int i = 0; i < 4; i++ ) { Point2d corner = center_ + delta; x[i] = corner.x(); y[i] = corner.y(); delta.rotate( M_PI_2 ); } polyline_draw (x, y, 4, color_, FILL); } void Square :: rotate ( double phi ) { cancel (); centerToUpperCorner_.rotate( phi ); draw (); } Square :: Square (const Point2d& lowerCorner, const Point2d& upperCorner, Color color) : center_( median(lowerCorner, upperCorner) ), centerToUpperCorner_( upperCorner - center_ ), color_( color ) { draw (); } void Square :: scale ( double s ) { cancel (); centerToUpperCorner_ *= s; draw (); } Square.cc

162. Codice Applicativo (Client) Come gestire cerchi e quadrati insieme? Costruisce un vettore di puntatori a cerchi, crea oggetti in memoria e salva i loro puntatori nel vettore. Itera sul vettore e invoca draw () per ogni elemento #include “Circle.h” #include “Square.h” int main() { Circle c1( Point2d (2.,3.), 4.23 ); Square r1( Point2d (2.,1.), Point2d (4.,3.) ); Circle * circles[ 10 ]; for ( int i = 0; i < 10; ++i ) { circles[ i ] = new Circle ( Point2d (i,i), 2. ); } for ( int i = 0; i < 10; ++i ) circles[ i ]-> draw (); return 0; } Main.cc

163. Polimorfismo Tutte le Shape s hanno la stessa interfaccia: draw, pick, move, fillColor... , ma ogni sottotipo diverso può avere la usa personale implementazione

164. Interfaccia astratta Interfaccia di metodi puramente virtuali class Shape { public: Shape () { } virtual ~Shape () { } virtual void moveAt (const Point2d& where) = 0 ; virtual void changeColor (Color newColor) = 0 ; virtual void scale (double s) = 0 ; virtual void rotate (double phi) = 0 ; virtual void draw () const = 0 ; virtual void cancel () const = 0 ; }; Shape.h #include “Shape.h” class Square : public Shape { // …. Il resto tutto uguale a prima }; Square.h #include “Circle.h” #include “Square.h” int main() { Shape * shapes[ 20 ]; int index = 0; for ( int i = 0; i < 10; i++ ) { Shape * s; s = new Circle ( Point2d(i, i), 2.) ); shapes[ index ++ ] = s; s = new Square ( Point2d(i, i), Point2d(i+1, i+2)) ); shapes[ index ++ ] = s; } for ( int i = 0; i < 20; i++ ) shapes[ i ]-> draw (); return 0; } Main.cc

165. Ereditarietà e riuso del codice Non si possono chiamare metodi virtuali in costruttori e distruttori (troppo presto, troppo tardi) Class CenteredShape : public Shape { public: CenteredShape (Point2d c, Color color = TRASPARENT) : center_(c), color_(color) { /*draw();*/ } ~Circle () { /*cancel();*/ } void moveAt ( const Point2d& ); void moveBy ( const Vector2d& ); void changeColor ( Color ); virtual void scale ( double ) = 0 ; virtual void rotate ( double ) = 0 ; virtual void draw () const = 0 ; virtual void cancel () const = 0 ; protected: Point2d center_; Color color_; }; CenteredShape.h #include “CenteredShape.hh” class Square : public CenteredShape { public: Square ( Point2d lowerCorner, Point2d upperCorner, Color col = TRASPARENT) : CenteredShape ( median(lowerCorner, upperCorner), col), touc_(upperCorner - center_) { draw(); } ~Square () { cancel(); } virtual void scale ( double s ) { cancel(); centerToUpperCorner_ *= s; draw(); } virtual void rotate ( double phi ); virtual void draw () const; virtual void cancel () const; private: Vector2d touc_; }; Square.h

169. Modello a cascata Analisi Disegno Produzione Testing Requisiti

170. Modello evoluzionario Requisiti Analisi Disegno Produzione Testing

174. Disegno Definizione delle interfacce Definizione di oggetti e classi Definizione degli stati e dell’implementazione Definizione delle relazioni

182. Rappresentazione delle classi operatori attibuti pubblico protetto privato Nome + metodo(arg) # metodo(arg) - metodo(arg) - dato - dato

183. Rappresentazione di una classe C++ in UML class Nome { private: Tipo1 variabile1 ; Tipo2 variabile2 ; Tipo3 variabile3 ; public: Nome (); ~Nome (); Tipo4 funzione1 ( arg ); protected: Tipo5 funzione2 ( arg ); private: Tipo6 funzione3 ( arg ); }; Nome.h Nome - variabile1 : Tipo1 - variabile2 : Tipo2 - variabile3 : Tipo3 + funzione1 (arg): Tipo4 # funzione2 (arg): Tipo5 - funzione3 (arg): Tipo6

184. Attributi e metodi Notazione di Rational Rose Publico ( + ) Privato ( - ) Protetto ( # )

189. Generalizzazione (ereditarietà) Ereditariet à virtuale!

190. Class Diagram di “Shape”

191. Class Diagram

192. Class Diagram

193. Object Sequence Diagram

194. Object Collaboration Diagram

195. CRC Classi, Responsabilità, Collaborazioni C D E F B A x y z s f q p w

207. Factory I client possono richiedere la creazione di un prodotto senza dipendervi La Factory dipende dai prodotti concreti, mentre i client dipendono solo da quelli astratti

208. Proxy Una richiesta da un client a un server, può essere mediata dal Proxy , che può compiere anche altre operazioni (I/O, caching, etc.)

209. Composite Il client può trattare componenti e compositi usando la stessa interfaccia. La composizione può essere ricursiva. Esempio : programmi di grafica

210. Gruppo di Shapes Il gruppo di shapes è il Composite La shape è il Component Le shapes concrete (Circle, Square, ecc...) sono le Leaf Circle, Square, ... draw( ) Shape draw( ) GroupofShapes draw( ) 1..* 1..* Client _components

211. Codice del modello composite #include “ Shape .h” class Circle : public Shape { public: Circle ( Point2D c, double r ): Shape(), center_(c), radius_(r) {} void draw () const { ; // draw circle } // altri metodi definiti per Circle pr ivate : double radius_ ; Point2D center_; }; Circle .h class Shape { public: Shape () {} virtual void draw () const = 0; // altri metodi virtuali ( = 0 ) }; Shape .h

212. Codice del modello composite #include “ Shape .h” class GroupofShapes : public Shape { public: typedef vector< Shape *> Container; typedef Container::const_iterator Iterator; GroupofShapes (){} void draw () const { Iterator p=components.begin(); Iterator pe=components.end(); while (p!=pe) { (*p)-> draw (); p++; } return; } // gli altri metodi sono definiti operando // sui componenti protected: Container components; }; GroupofShapes .h

213. Strategy Il pattern Strategy permette di scegliere l’algoritmo da eseguire a run-time. Nuovi algoritmi possono essere introdotti senza modificare il codice utente.

214. Observer Lo stato dell’ Observer dipende dallo stato del Subject . Il Subject notifica a tutti gli Observer registrati che il suo stato è cambiato.