summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--.gitignore1
-rw-r--r--doc/.ninja_depsbin16 -> 0 bytes
-rw-r--r--doc/.ninja_log2
-rw-r--r--doc/quick_cplusplus.md96
-rw-r--r--doc/quick_cplusplus.pdfbin212718 -> 240889 bytes
5 files changed, 95 insertions, 4 deletions
diff --git a/.gitignore b/.gitignore
index 0753705..2be2a5c 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,2 +1,3 @@
**/*build
**/*.swp
+**/.ninja_*
diff --git a/doc/.ninja_deps b/doc/.ninja_deps
deleted file mode 100644
index 2afb5cc..0000000
--- a/doc/.ninja_deps
+++ /dev/null
Binary files differ
diff --git a/doc/.ninja_log b/doc/.ninja_log
deleted file mode 100644
index 891c53f..0000000
--- a/doc/.ninja_log
+++ /dev/null
@@ -1,2 +0,0 @@
-# ninja log v5
-0 770 1548439603 quick_cplusplus.pdf 5be4e5805f2d04b5
diff --git a/doc/quick_cplusplus.md b/doc/quick_cplusplus.md
index 411e0a3..105b4e0 100644
--- a/doc/quick_cplusplus.md
+++ b/doc/quick_cplusplus.md
@@ -131,8 +131,12 @@ chiamata anche STL) che giustamente è chiamato `std`. `std` contiene molte cose
molto utili come per esempio la `std::string`.
## Allocazione di memoria dinamica
-Come sapete è spesso utile se non necessario allocare della memoria "dinamica",
-ossia non controllata a tempo di compilazione.
+Come sapete è spesso utile se non necessario allocare della memoria "dinamica".
+A differenza del C nel C++ non ha una suddivisione cristallina tra le regioni
+di memoria quindi non si parla di stack, heap e bss (in realtà ci sono ma è
+meglio non pensarci troppo) ma semplicemente di memoria "statica" e
+"diniamica".
+
In C esistono le funzioni `malloc()` e `free()` per richiedere e liberare della
memoria. In C++ la funzione è stata integrata con delle *keywords* quali `new`
e `delete`, che si usano come segue.
@@ -145,6 +149,9 @@ int *data = new int[10];
// data = NULL;
delete data;
```
+Questo permette di fare tutte le cose sporche con i puntatori come in C, ma
+più avanti sarà mostrato come abbandonare questa fabbrica di codice che causa
+`segmentation fault`, utilizzando una cosa chiamata RAII.
## References
I puntatori del C sono molto utili, non possiamo negarlo, ma come tutti sanno
@@ -243,3 +250,88 @@ Giustamente non compila, perché il compiler non sa quale delle due funzioni si
vuole utilizzare. Ci propone però le varianti che ha trovato "`note:
candidate`" che potrebbero essere valide.
+
+
+# Classe: lo struct glorificato
+Se ancora non lo sapevate, il C++ appartiene ad una categoria di linguaggi di
+programmazione detta di paradigma *orientato ad oggetti* (Object Oriented
+Programming, OOP).
+
+Ciò non significa che siete obbligati ad abbandonare l'amato codice lineare,
+ma non potete nemmeno pretendere che l'OOP non esista.
+
+## Perché esiste `class`
+Il concetto di classe arriva da un'altra idea chiamata *incapsulazione*.
+Vediamo un esempio che ne dimostra l'utilità (importante: non si deve usare
+**sempre** l'incapsulazione, si deve usare solo quando **serve**).
+
+Okay, quindi prendiamo questo `struct`
+```C++
+struct mytime {
+ unsigned hour; // from 0 to 23
+ unsigned min; // from 0 to 59
+ unsigned sec; // from 0 to 59
+};
+```
+Molto semplice. Il problema di questo è che si può fare questo:
+```C++
+mytime when_you_will_be_productive = { 23, 61, 99 };
+when_you_will_be_productive.hour = 1234;
+```
+Ma come sapete, se non usate un qualche orologio esotico, le 22:61:99 non
+esistono. Quindi servirebbe una cosa del genere:
+```C++
+mytime make_mytime(unsigned hour, unsigned min, unsigned sec) {
+ if ((hour > 23) || (min > 59) || (sec > 59))
+ // I'll explain this later, bear with me
+ throw std::runtime_error("invalid time");
+
+ return mytime { hour, min, sec };
+}
+```
+Ma la gente, stupida com'è può comunque decidere creare degli `struct mytime`
+invalidi a mano. Quindi in C++ si fa il seguente:
+```C++
+class mytime {
+private:
+ unsigned m_hour;
+ unsigned m_min;
+ unsigned m_sec;
+
+public:
+ // this is called 'constructor'
+ mytime(unsigned hour, unsigned min, unsigned sec);
+
+ // these are 'member functions'
+ void set(unsigned hour, unsigned min, unsigned sec);
+
+ unsigned hour();
+ unsigned min();
+ unsigned sec();
+}
+```
+I membri dello `struct`, ora detto classe, sono stati resi "privati".
+E abbiamo messo delle funzioni come membri, che si chiamano quindi *funzioni
+membro*.
+
+Le funzioni membro hanno diritto di modificare i membri privati
+(come `m_hour`), mentre il mondo esterno no. Come si presentano?
+```C++
+// the variable is created by calling the constructor
+mytime example(14, 23, 55);
+
+// we can call a member function
+unsigned hour = example.hour();
+
+// but we CANNOT read or assign a private member
+example.m_min = 23; // compile error
+
+// except through a member function
+example.set(16, 23, 34);
+```
+
+Ora, non mostro l'implementazione (nel file `.cpp`) di queste funzioni, siccome
+si mostra la dichiarazione nel file header. Ma si può intuire che
+`mytime::set(...)` è simile l'esempio precedente di `make_mytime(...)`, ossia
+imposta i valori controllando che sono validi. Mentre le altre ritornano
+semplicemente una copia del valore chiesto.
diff --git a/doc/quick_cplusplus.pdf b/doc/quick_cplusplus.pdf
index ac74aa3..96e3acf 100644
--- a/doc/quick_cplusplus.pdf
+++ b/doc/quick_cplusplus.pdf
Binary files differ