lezione 4

teoria/exceptions.cpp

@@ -0,0 +1,93 @@
+#include<iostream>
+using namespace std;
+
+void exceptions();
+void noExceptFun() noexcept;
+void nestedTryCatch();
+
+int main(){
+  exceptions();
+  nestedTryCatch();
+  try{
+    noExceptFun();
+  }catch(bad_alloc ex){
+    cout<<"Questo punto non verrà mai raggiunto";
+  }
+}
+
+void nestedTryCatch(){
+  try{
+    try{
+      throw exception();
+    }catch(exception ex){
+      throw ex;
+    }
+  }catch(exception ex){
+    cout<<"Eccezione catturata"<<endl;
+  }
+}
+
+void noExceptFun() noexcept{
+  /*
+    Le funzioni noexcept possono lanciare eccezioni. Se sono catturate da
+    un try-catch non cambia niente da una normale funzione, mentre se l'eccezione
+    è fuori un try-catch allora il programma termina improvvisamente
+    (anche se la funzione richiamante ha un try-catch). Ovvero le eccezioni
+    non vengono mai propagate.
+  */
+  try{
+    throw bad_alloc();
+  }catch(bad_alloc){
+    cout<<"OK"<<endl;
+  }
+
+  throw bad_alloc(); // il programma termina qui.
+}
+
+void exceptions(){
+
+  /*
+    Viene preso il primo catch che corrisponde all'eccezione generata
+    o il primo che ne è superclasse:
+  */
+
+  try{
+    throw logic_error("Errore logico");
+  }catch(exception& ex){
+    /*
+    Se non avessi messo &, funzionava lo stesso ma non stampava "errore logico"
+    (questo discorso sembra valere solo per eccezioni "exception")
+    */
+    cout<<"Verrà preso questo catch qui. "<<ex.what()<<endl;
+  }catch(logic_error ex){
+    cout<<"Questo catch non verrà preso.";
+  }
+
+  try{
+    throw logic_error("Errore logico");
+  }catch(logic_error ex){ // Se non avessi messo &, funzionava lo stesso ma non stampava "errore logico"
+    cout<<"Verrà preso questo catch qui. "<<ex.what()<<endl;
+  }catch(exception ex){
+    cout<<"Questo catch non verrà preso.";
+  }
+
+  try{
+    throw runtime_error("Errore a runtime");
+  }catch(logic_error ex){ // Se non avessi messo &, funzionava lo stesso ma non stampava "errore logico"
+    cout<<"Questo catch non verrà preso.";
+  }catch(exception ex){
+    cout<<"Verrà preso questo catch qui. "<<ex.what()<<endl;
+  }
+
+/*
+  Eccezioni non standard
+*/
+  try{
+    throw 1.3;
+  }catch(exception ex){
+    cout<<"Non verrà preso";
+  }catch(...){
+    cout<<"Tutte le eccezioni non-standard verranno prese qui"<<endl;
+  }
+
+}

teoria/friendFunction.cpp

@@ -10,7 +10,7 @@ struct Studente{
         int secureNumber = 999;
 };
 void printSecureNumber(Studente s){
-  cout<<s.secureNumber<<endl;
+  cout<<s.secureNumber<<endl;  // essendo funzione friend, posso accedere ai campi privati
 }
 int main(){
   Studente st;

teoria/pointerToFunction.cpp

@@ -0,0 +1,55 @@
+#include<iostream>
+#include <functional> // Solo per puntatori alla C++
+
+using namespace std;
+
+int func(int a);
+void C_like_functionPointer();
+void C_like_typedef_functionPointer();
+void CPP_like_functionPointer();
+void CPP_like_typedef_functionPointer();
+
+int main(){
+  C_like_functionPointer();
+  C_like_typedef_functionPointer();
+  CPP_like_functionPointer();
+  CPP_like_typedef_functionPointer();
+  return 0;
+}
+
+int func(int a){
+  return 2*a;
+}
+
+void CPP_like_typedef_functionPointer(){
+  // funptrType è un nuovo tipo che definisce puntatori a funzione di tipo int f(int)
+  typedef function<int(int)> funptrType;
+  funptrType ptr = func;
+  cout<<ptr(3)<<endl;
+  // cout<<(*funptr)(3); //illegale alla C++
+}
+
+void CPP_like_functionPointer(){
+  // funptr è un PUNTATORE a funzione
+  function<int(int)> funptr = nullptr;
+  funptr = &func;
+  funptr = func;
+  cout<<funptr(3);
+  // cout<<(*funptr)(3); //illegale alla C++
+}
+
+void C_like_functionPointer(){
+  // sto creando un puntatore a funzione
+  int (*funptr)(int);
+  funptr = &func;
+  funptr = func; //equivalente
+  cout<<(*funptr)(3)<<" "<<funptr(3)<<endl;
+}
+void C_like_typedef_functionPointer(){
+  // sto creando un nuovo tipo: puntatore a funzione int che prende in int in ingresso
+  typedef int (*funptrType)(int);
+  funptrType pointer;
+  pointer = &func;
+  pointer = func; // equivalente
+  cout<<(*pointer)(3)<<" "<<pointer(3)<<endl;
+}

teoria/randomNumbers.cpp

@@ -0,0 +1,27 @@
+#include<iostream>
+#include<random>
+
+#include<stdlib.h> // Per implementazione alla C [sconsigliato]
+#include<time.h> // Per implementazione alla C [sconsigliato]
+
+using namespace std;
+
+void C_like_randomNumbers();
+void Cpp_like_randomNumbers();
+int main(){
+  Cpp_like_randomNumbers();
+  return 0;
+}
+
+void Cpp_like_randomNumbers(){
+  default_random_engine gen(random_device{}());
+  uniform_int_distribution<int> dist(0,100);
+  for(int i=1;i<=15;i++){
+    cout<<dist(gen)<<endl;
+  }
+}
+
+void C_like_randomNumbers(){ // sconsigliato
+  srand(time(NULL)); // seme (seed)
+  printf("%d\n",rand());
+}

teoria/stringhe.cpp

@@ -0,0 +1,33 @@
+#include<iostream> // include anche <string>
+using namespace std;
+
+int main(){
+  string s1 = "Alan";
+  string s2 = {"Turing"};
+  string s3{"Kurt"};
+  string s4("Godel");
+
+  string stringa_concatenata = s1 + s3; // l'operatore + è stato overloaded per le stringhe
+  cout<<stringa_concatenata<<endl;
+
+  string input_string;
+  cin>>input_string; // se si inserisce "Alan Turing" verrà preso solo "Alan"
+  cout<<input_string<<endl;
+  getline(cin,input_string); // se si inserisce "Alan Turing" verrà preso "Alan Turing"
+  cout<<input_string<<endl;
+
+  /*
+      - - - ATTENZIONE - - -
+      Nell'esempio  precedente se si inserisce "Alan Turing" stamperà solo "Alan",
+      però non richiede un nuovo inserimento su getline() perché " Turing" rimane
+      nel buffer e infatti stampa " Turing".
+  */
+
+  string s6 = "stringamoltolunga";
+  cout<<s6.size()<<endl;
+  s6.clear();
+  cout<<s6<<endl;
+  cout<<s6.size()<<endl;
+  return 0;
+
+}