From dec92b05fbd76b66f735feeff7e5c49597057e5b Mon Sep 17 00:00:00 2001 From: Tommaso Date: Mon, 24 Oct 2016 14:54:58 +0200 Subject: Bring this version up to date with the english one (#2503) * Bring this version up to date with the english one The following commits were taken into consideration and translated into italian: c3e769e4ac50d4475a530969663e073f4ff002ca fd26c8ddfb6d4bfa969b323a2e98ce1b74bc8127 19ead59c1fde3623bc29e1fe56f33f2587c97d3a e6866f5a26dab28d2d1b5628fbb18139c36a5139 32f18cd992b5b6988a3b37eaa533f8215d83fe2e c805148618f5b2679d6581ff41885abc7140fd4d 4a1a6857ce30f19f8c04dcca4571bb27f7dc36d0 fa2b171008061bc82cf9b35e0470eebeaecb4a26 e1016455d5e4472e7a533c8cdd6df8ae4f2e7854 1bb2535efda67de687d4eb94a0f964f9c06dcd4a 1d562740f3d3b68fbb51a45f66ae6b60eee7b2de 281ba5b37a9e4e42d33442b0d3a062d99c964a95 c50ff9299651ba3c856ee23cbdabeda2784b864c 47679dfcbe82811b7042a5994baab448adc15dd4 042ed5038101d59a9d438cc2410fd9c91a343753 * Bring this version up to date with the english one The following commits were taken into consideration and translated into italian: c3e769e4ac50d4475a530969663e073f4ff002ca fd26c8ddfb6d4bfa969b323a2e98ce1b74bc8127 19ead59c1fde3623bc29e1fe56f33f2587c97d3a e6866f5a26dab28d2d1b5628fbb18139c36a5139 32f18cd992b5b6988a3b37eaa533f8215d83fe2e c805148618f5b2679d6581ff41885abc7140fd4d 4a1a6857ce30f19f8c04dcca4571bb27f7dc36d0 fa2b171008061bc82cf9b35e0470eebeaecb4a26 e1016455d5e4472e7a533c8cdd6df8ae4f2e7854 1bb2535efda67de687d4eb94a0f964f9c06dcd4a 1d562740f3d3b68fbb51a45f66ae6b60eee7b2de 281ba5b37a9e4e42d33442b0d3a062d99c964a95 c50ff9299651ba3c856ee23cbdabeda2784b864c 47679dfcbe82811b7042a5994baab448adc15dd4 042ed5038101d59a9d438cc2410fd9c91a343753 --- it-it/c++-it.html.markdown | 283 ++++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 270 insertions(+), 13 deletions(-) (limited to 'it-it') diff --git a/it-it/c++-it.html.markdown b/it-it/c++-it.html.markdown index 92ebc165..4af30176 100644 --- a/it-it/c++-it.html.markdown +++ b/it-it/c++-it.html.markdown @@ -8,6 +8,7 @@ contributors: - ["Connor Waters", "http://github.com/connorwaters"] translators: - ["Robert Margelli", "http://github.com/sinkswim/"] + - ["Tommaso Pifferi", "http://github.com/neslinesli93/"] lang: it-it --- @@ -151,7 +152,7 @@ namespace Primo { namespace Secondo { void foo() { - printf("Questa è Secondo::foo\n") + printf("Questa è Secondo::foo\n"); } } @@ -805,6 +806,94 @@ void faiQualcosaConUnFile(const std::string& nomefile) // sono tutti automaticamente distrutti con i loro contenuti quando escono dalla visibilità. // - I mutex usano lock_guard e unique_lock +// I contenitori che utilizzano chiavi non-primitive (classi personalizzate) +// richiedono la funzione di confronto nell'oggetto stesso, o tramite un puntatore a funzione. +// Le chiavi primitive hanno funzioni di confronto già definite, ma puoi sovrascriverle. +class Foo { +public: + int j; + Foo(int a) : j(a) {} +}; +struct funzioneDiConfronto { + bool operator()(const Foo& a, const Foo& b) const { + return a.j < b.j; + } +}; +// Questo non è permesso, anche se qualche compilatore potrebbe non dare problemi +//std::map fooMap; +std::map fooMap; +fooMap[Foo(1)] = 1; +fooMap.find(Foo(1)); -- vero + +/////////////////////////////////////// +// Espressioni Lambda (C++11 e superiori) +/////////////////////////////////////// + +// Le espressioni lambda (più semplicemente "lambda") sono utilizzate +// per definire una funzione anonima nel punto in cui viene invocata, o +// dove viene passata come argomento ad una funzione + +// Ad esempio, consideriamo l'ordinamento di un vettore costituito da una +// coppia di interi, utilizzando il secondo elemento per confrontare +vector > tester; +tester.push_back(make_pair(3, 6)); +tester.push_back(make_pair(1, 9)); +tester.push_back(make_pair(5, 0)); + +// Passiamo una lambda come terzo argomento alla funzione di ordinamento +// `sort` è contenuta nell'header +sort(tester.begin(), tester.end(), [](const pair& lhs, const pair& rhs) { + return lhs.second < rhs.second; +}); + +// Nota bene la sintassi utilizzata nelle lambda: +// [] serve per "catturare" le variabili. +// La "Lista di Cattura" definisce tutte le variabili esterne che devono essere disponibili +// all'interno della funzione, e in che modo. +// La lista può contenere: +// 1. un valore: [x] +// 2. un riferimento: [&x] +// 3. qualunque variabile nello scope corrente, per riferimento [&] +// 4. qualunque variabile nello scope corrente, per valore [=] +// Esempio: + +vector id_cani; +// numero_cani = 3; +for(int i = 0; i < 3; i++) { + id_cani.push_back(i); +} + +int pesi[3] = {30, 50, 10}; + +// Mettiamo che vuoi ordinare id_cani in base al peso dei cani +// Alla fine, id_cani sarà: [2, 0, 1] + +// Le lambda vengono in aiuto + +sort(id_cani.begin(), id_cani.end(), [&pesi](const int &lhs, const int &rhs) { + return pesi[lhs] < pesi[rhs]; +}); +// Nota come abbiamo catturato "pesi" per riferimento nell'esempio. +// Altre informazioni sulle lambda in C++: http://stackoverflow.com/questions/7627098/what-is-a-lambda-expression-in-c11 + +/////////////////////////////// +// Ciclo For semplificato(C++11 e superiori) +/////////////////////////////// + +// Puoi usare un ciclo for per iterare su un tipo di dato contenitore +int arr[] = {1, 10, 3}; + +for(int elem: arr) { + cout << elem << endl; +} + +// Puoi usare "auto" senza preoccuparti del tipo degli elementi nel contenitore +// Ad esempio: + +for(auto elem: arr) { + // Fai qualcosa con `elem` +} + /////////////////////// // Roba divertente ////////////////////// @@ -855,20 +944,188 @@ Foo f1; f1 = f2; -// Come deallocare realmente le risorse all'interno di un vettore: -class Foo { ... }; -vector v; -for (int i = 0; i < 10; ++i) - v.push_back(Foo()); +/////////////////////////////////////// +// Tuple (C++11 e superiori) +/////////////////////////////////////// + +#include + +// Concettualmente le tuple sono simili alle strutture del C, ma invece di avere +// i membri rappresentati con dei nomi, l'accesso agli elementi avviene tramite +// il loro ordine all'interno della tupla. + +// Cominciamo costruendo una tupla. +// Inserire i valori in una tupla +auto prima = make_tuple(10, 'A'); +const int maxN = 1e9; +const int maxL = 15; +auto seconda = make_tuple(maxN, maxL); + +// Vediamo gli elementi contenuti nella tupla "prima" +cout << get<0>(prima) << " " << get<1>(prima) << "\n"; // stampa : 10 A + +// Vediamo gli elementi contenuti nella tupla "seconda" +cout << get<0>(seconda) << " " << get<1>(seconda) << "\n"; // stampa: 1000000000 15 + +// Estrarre i valori dalla tupla, salvandoli nelle variabili +int primo_intero; +char primo_char; +tie(primo_intero, primo_char) = prima; +cout << primo_intero << " " << primo_char << "\n"; // stampa : 10 A + +// E' possibile creare tuple anche in questo modo +tuple terza(11, 'A', 3.14141); + +// tuple_size ritorna il numero di elementi in una tupla (come constexpr) +cout << tuple_size::value << "\n"; // stampa: 3 + +// tuple_cat concatena gli elementi di tutte le tuple, nell'esatto ordine +// in cui sono posizionati all'interno delle tuple stesse +auto tupla_concatenata = tuple_cat(prima, seconda, terza); +// tupla_concatenata diventa = (10, 'A', 1e9, 15, 11, 'A' ,3.14141) + +cout << get<0>(tupla_concatenata) << "\n"; // stampa: 10 +cout << get<3>(tupla_concatenata) << "\n"; // stampa: 15 +cout << get<5>(tupla_concatenata) << "\n"; // stampa: 'A' + + +///////////////////// +// Contenitori +///////////////////// + +// I Contenitori della "Standard Template Library", ovvero la libreria standard +// dei template contenuti nel C++, sono template predefiniti. +// I Contenitori si occupano di come allocare lo spazio per gli elementi contenuti, +// e forniscono funzioni per accedervi e manipolarli + +// Vediamo alcuni tipi di contenitori: + +// Vector (array dinamici/vettori) +// Permettono di definire un vettore, o una lista di oggetti, a runtime +#include +vector nome_vettore; // usato per inizializzare un vettore +cin >> val; +nome_vettore.push_back(val); // inserisce il valore di "val" nel vettore + +// Per iterare in un vettore, abbiamo due possibilità: +// Ciclo normale +for(int i=0; i::iterator it; // inizializza l'iteratore per il vettore +for(it=nome_vettore.begin(); it!=nome_vettore.end();++it) +// Nota che adesso non cicla più sugli indici, ma direttamente sugli elementi! + +// Per accedere agli elementi del vettore +// Operatore [] +var = nome_vettore[indice]; // Assegna a "var" il valore del vettore all'indice dato + + +// Set (insiemi) +// Gli insiemi sono contenitori che memorizzano elementi secondo uno specifico ordine. +// Gli insiemi vengono per lo più utilizzati per memorizzare valori unici, secondo +// un ordine, senza scrivere ulteriore codice. + +#include +set insieme; // Inizializza un insieme di interi +insieme.insert(30); // Inserisce il valore 30 nell'insieme +insieme.insert(10); // Inserisce il valore 10 nell'insieme +insieme.insert(20); // Inserisce il valore 20 nell'insieme +insieme.insert(30); // Inserisce il valore 30 nell'insieme +// Gli elementi dell'insieme sono: +// 10 20 30 + +// Per cancellare un elemento +insieme.erase(20); // Cancella l'elemento con valore 20 +// L'insieme contiene adesso: 10 30 + +// Per iterare su un insieme, usiamo gli iteratori +set::iterator it; +for(it=insieme.begin();it +map mia_mappa; // Inizializza una mappa che usa i char come chiave, e gli interi come valore + +mia_mappa.insert(pair('A',1)); +// Inserisce il valore 1 per la chiave A +mia_mappa.insert(pair('Z',26)); +// Inserisce il valore 26 per la chiave Z + +// Per iterare +map::iterator it; +for (it=mia_mappa.begin(); it!=mia_mappa.end(); ++it) + std::cout << it->first << "->" << it->second << '\n'; +// Stampa: +// A->1 +// Z->26 + +// Per trovare il valore corrispondente ad una data chiave +it = mia_mappa.find('Z'); +cout << it->second; +// Stampa: 26 + + +/////////////////////////////////// +// Operatori logici e bitwise(bit-a-bit) +////////////////////////////////// + +// La maggior parte di questi operatori in C++ sono gli stessi degli altri linguaggi + +// Operatori logici + +// Il C++ usa la "Short-circuit evaluation" per le espressioni booleane. Cosa significa? +// In pratica, in una condizione con due argomenti, il secondo viene considerato solo se +// il primo non basta a determinate il valore finale dell'espresione. + +true && false // Effettua il **and logico** e ritorna falso +true || false // Effettua il **or logico** e ritorna vero +! true // Effettua il **not logico** e ritorna falso + +// Invece di usare i simboli, si possono usare le keyword equivalenti +true and false // Effettua il **and logico** e ritorna falso +true or false // Effettua il **or logico** e ritorna vero +not true // Effettua il **not logico** e ritorna falso + +// Operatori bitwise(bit-a-bit) + +// **<<** Operatore di Shift a Sinistra +// << sposta i bit a sinistra +4 << 1 // Sposta a sinistra di 1 i bit di 4, ottenendo 8 +// x << n in pratica realizza x * 2^n + + +// **>>** Operatore di Shift a Destra +// >> sposta i bit a destra +4 >> 1 // Sposta a destra di 1 i bit di 4, ottenendo 2 +// x >> n in pratica realizza x / 2^n -// La riga seguente riduce la dimensione di v a 0, ma il distruttore non -// viene chiamato e dunque le risorse non sono deallocate! -v.empty(); -v.push_back(Foo()); // Il nuovo valore viene copiato nel primo Foo che abbiamo inserito +~4 // Effettua il NOT bit-a-bit +4 | 3 // Effettua il OR bit-a-bit +4 & 3 // Effettua il AND bit-a-bit +4 ^ 3 // Effettua il XOR bit-a-bit -// Distrugge realmente tutti i valori dentro v. Vedi la sezione riguardante gli -// oggetti temporanei per capire come mai funziona così. -v.swap(vector()); +// Le keyword equivalenti sono +compl 4 // Effettua il NOT bit-a-bit +4 bitor 3 // Effettua il OR bit-a-bit +4 bitand 3 // Effettua il AND bit-a-bit +4 xor 3 // Effettua il XOR bit-a-bit ``` Letture consigliate: -- cgit v1.2.3