Soluzione del 15 febbraio 2016

Transcript

1 Soluzione del 15 febbraio 2016 Problema 1 Un programma che effettua quanto richiesto, senza alcuna pretesa da parte di chi l avesse scritto, potrebbe essere il seguente: # include <iostream> # include <cmath> # include <cstring> using namespace std; char cifre[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z,, #, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z }; template <int N, class U> char * base64(u numero, int (&x)[n]) {char * ret; U numero = numero >= 0? numero : - numero; unsigned int ordinillo, segno = numero < 0, numchar = segno; double ordine = numero? log10(numero)/log10(64) : 0; ordinillo = (unsigned int)ordine + 1; numchar += ordinillo; ret = new char[1+numchar]; ret[numchar] = 0; if(!numero) {ret[0] = 0 ; return ret;} else if(segno) ret[0] = - ; ordinillo = 1; while(numero) {unsigned int scarto = numero % 64; ret[numchar-ordinillo++] = cifre[scarto]; numero /= 64;} return ret;} template <class... U> char * base64(char *s, U... v) {return s;} unsigned int conv(char u) {try {for(unsigned int i=0; i!= 64; ++i) if(u == cifre[i]) return i; throw 0;} catch(...) {cerr << "non convertibile. Valore illegale: " << flush; throw;}} template <class U> void base10(char * s, U* uu) {U ret{}, pot{1}; unsigned int numchar = strlen(s); if(numchar == 1 && s[0] == 0 ) {*uu = ret; return;} try

2 {for(unsigned int pos = numchar-1; pos; --pos) ret += pot * conv(s[pos]), pot *= 64; if(s[0] == - ) ret *= -1; else ret += pot * conv(s[0]);} catch(...) {cerr << [ << s << "]\n" << flush; throw;} *uu = ret;} int main() {int x[1]; cout << base64(-12,x) << endl; cout << base64(8192,x) << endl; cout << base64(1000,x) << endl; cout << base64(9,x) << endl; cout << base64(-9,x) << endl; cout << base64(64,x) << endl; cout << base64(63,x) << endl; cout << base64(0xffffffffffffffff,x) << endl; cout << base64(const cast<char*>("tanto va la gatta al lardo")) << endl; cout << "\n\n\n \n\n\n"; int i; base10(const cast<char*>("fc"), &i); cout << i << endl; short int s; base10(const cast<char*>("200"), &s); cout << s << endl; base10(const cast<char*>("-c"), &i); cout << i << endl; base10(const cast<char*>("0"), &i); cout << i << endl; try {base10(const cast<char*>("@"), &i); cout << i << endl;} catch(...) {} unsigned long long int u; base10(const cast<char*>("fzzzzzzzzzz"), &u); cout << u << endl;} Naturalmente la funzione main è solo dimostrativa. L unica furbata del codice consiste nell aver introdotto una coppia di funzioni template omonime, le due base64, che si escludono vicendevolmente per evidenti type SFINAE che si producono nei diversi tentativi di istanziazione. Un codice che avrebbe comportato il 30 senza passare dal via potrebbe essere come il seguente, ampiamente autocommentato # include <iostream> # include <fstream> # include <cstring> # include <cmath> using namespace std; // le 64 cifre (ordinate) da usare per la base 64 char cifre[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F, G, H, I, J, K, L, M, N,

3 O, P, Q, R, S, T, U, V, W, X, Y, Z,, #, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z }; // una coppia di funzioni, la seconda template, // per la conversione inversa da base64 a base 10 unsigned int conv(char u) {try {for(unsigned int i=0; i!= 64; ++i) if(u == cifre[i]) return i; throw 0;} catch(...) {cerr << "non convertibile. Valore illegale: " << flush; throw;}} template <class U> void base10(char * s, U* uu) {U ret, pot1; unsigned int numchar = strlen(s); if(numchar == 1 && s[0] == 0 ) {*uu = ret; return;} try {for(unsigned int pos = numchar-1; pos; --pos) ret += pot * conv(s[pos]), pot *= 64; if(s[0] == - ) ret *= -1; else ret += pot * conv(s[0]);} catch(...) {cerr << [ << s << "]\n" << flush;} *uu = ret;} // una funzione template attivata SOLO se riceve un // argomento di tipo riconducibile a intero: in tal caso // lo converte in base 64 e lo restituisce come char*; // si tratta della prima delle due funzioni proposte nell altra soluzione template <class U> char * base64(typename enable if<is integral<u>::value, U> :: type numero) {char * ret; U numero = numero >= 0? numero : - numero; unsigned int ordinillo, segno = numero < 0, numchar = segno; double ordine = numero? log10(numero)/log10(64) : 0; ordinillo = (unsigned int)ordine + 1; numchar += ordinillo; ret = new char[1+numchar]; ret[numchar] = 0; if(!numero) {ret[0] = 0 ; return ret;} else if(segno) ret[0] = - ; ordinillo = 1; while(numero) {unsigned int scarto = numero % 64; ret[numchar-ordinillo++] = cifre[scarto]; numero /= 64;} return ret;}

4 // la controparte funzione template attivata SOLO nel caso opposto // non fa assolutamente nulla se non qualificare const il valore // restituito, per poterci prender dentro anche eventuali argomenti // trasmessi come stringhe virgolettate template <class U> const char * base64(typename enable if<!is integral<u>::value, U> :: type u) {return u;} // dichiarazioni ANTICIPATE di due classi: // servono alla definizione della successiva struct del piffero class mioistream; class mioostream; // una struct il cui stesso nome lascia capire che // l utilizzatore finale non la istanzierà mai esplicitamente. // Viene contestualmente creata una sua istanza nell ambito globale // e quindi, come ben si sa, visibile OVUNQUE cominciando da QUI. // La struct del piffero ha come unici membri due puntatori: // uno a ostream e l altro a istream. Inoltre per essa sono // dichiarati due operatori di input e output che restituiscono // riferimenti alle due classi di cui si è data dichiarazione // anticipata. Questo è possibile purché tali classi, una volta // definite, lo siano come eredi di istream e di ostream // (oppure di qualche loro erede). struct del piffero {ostream *f; istream *i; friend mioistream&operator>>(istream&, del piffero&); friend mioostream&operator<<(ostream&, del piffero&);}delpiffero; // definizione della classe mioistream come pubblica erede // di ifstream: come tale possederà tutti i metodi non privati // di quella classe (comprese tutte le segnature dei costruttori, // che sono ereditati a loro volta grazie alla direttiva using) // oltre a quello che vi si aggiunge. L averla resa erede di // ifstream, invece che di istream, implica che, almeno in questo // programma dimostrativo, non si possano leggere dati dallo standard // input tramite istanze di questa classe. Anche in questo caso // viene contestualmente istanziato un oggetto globale nomato imio. struct mioistream : public ifstream {using istream::istream; using ifstream::ifstream; // la seguente operator>>, MEMBRO di mioistream, è l aggiunta // più significativa e, in definitiva, la ragione per cui questa // classe viene definita: si osservi che si tratta di un membro // templatizzato che restituisce, provvidamente, un riferimento // alla classe stessa. template <class U> mioistream& operator >> (U& u) {// stessa struttura, mutatis mutandis,

5 // della template <class U> mioostream& operator << // definita come membro dell oggetto omio seguente char * buff; streamsize qui, qua; qui = tellg(), ignore(20000, ), qua = tellg(), seekg(qui), buff = new char[qua-qui+1], * delpiffero.i >> buff; clog << "devo interpretare come base64 ["<< buff << "]\n"; base10(buff, &u); return *this;}}imio; // la classe speculare di mioistream, dedicata alle operazioni // di scrittura. // Si osservi che le operazioni di scrittura EFFETTIVE // avvengono attraverso l oggetto puntato dal membro f di delpiffero. struct mioostream : public ofstream {using ostream::ostream; using ofstream::ofstream; template <class U> mioostream& operator << (U u) {*delpiffero.f << base64<u>(u); return *this;}}omio; // definizione della friend mioistream& operator >> // dichiarata per la struct del piffero mioistream&operator>>(istream&i, del piffero&d) {d.i = &i; // questa operator funge da "wrapper" per la operator >> di imio... return imio;} // definizione della friend mioostream& operator << // dichiarata per la struct del piffero mioostream& operator<<(ostream&o, del piffero& d) {d.f = &o; // questa operator funge da "wrapper" per la operator << di omio... return omio;} // e INFINE ecco la definizione del manipolatore auspicato // che sarà quello usato dall utilizzatore finale: si osservi // che restituisce un riferimento a del piffero del piffero& x64() {clog << "sono x64 e sono il manipolatore ATTIVANTE la base64\n"; return delpiffero;} // una breve main dimostrativa: ovviamente se si volesse utilizzare questo // manipolatore durante operazioni di lettura e scrittura di // Pappi e Cicci occorrerebbe NON SOLO che sia i Pappi sia i Cicci

6 // abbiano le loro operator<< e operator>> scritte a puntino // (il che, francamente, appare SCONTATAMENTE BANALE), ma anche // che abbiano una operator di conversione a qualche tipo intero, // altrimenti non si capirebbe il significato di una lettura o // scrittura in base 64 di un Pappo o di un Ciccio. // // Si osservi come il comportamento standard delle operazioni di I/O // si ricupera immediatamente per omissione del manipolatore. int main() {int k{-77}; char linea[201]; ofstream *ossa = new ofstream; ossa->open("peppo"); *ossa << x64() << "tanto va la gatta"; // inserimento vano del manipolatore *ossa << endl; *ossa << 200 << \n ; // scrittura della costante intera 200 // eseguite l analisi grammaticale della seguente linea di codice // e CAPITE, in base a tutto quanto è stato già detto, // COME e PERCHÉ l ambaradan funziona. *ossa << x64() << k; // scrittura di k in base64: nel file appare -1D *ossa << \n ; *ossa << k+1; // scrittura in base normale di k+1, ossia -76 *ossa << \n ; *ossa << k << endl; // scrittura in base normale di k, ossia -77 ossa->close(); ifstream *issa = new ifstream; issa->open("peppo"); issa -> getline(linea, 200), clog << "letto da file [" << linea << "]\n"; // letta correttamente la prima linea streamsize qui; qui = issa->tellg(); *issa >> k; clog << "letto da file " << k << endl; // letta correttamente la costante 200 issa->seekg(qui); *issa >> x64() >> k; clog << "letto da file " << k << endl; // riletto lo STESSO dato in base64 *issa >> x64() >> k; clog << "letto da file " << k << endl; // letto correttamente 1D in base64 *issa >> k; clog << "letto da file " << k << endl; // letto correttamente k in base normale *issa >> x64() >> k; clog << "letto da file " << k << endl; // letto correttamente k in base64 } Problema 2 Questo problema è addirittura banale: viene proposto un codice che lo risolve senza ulteriori commenti. Si lascia agli studenti l autodidattica della spiegazione. L unica annotazione che merita di essere fatta è che il trattamento delle lettere accentate necessita che la LOCALE in esercizio nella SHELL le supporti adeguatamente, altrimenti saranno attraversate come aria fresca. # include <iostream> # include <fstream>

7 # include <sstream> # include <string> using namespace std; char PencaPolla(char a) {char alfabeto minuscolo[] { $, a, d, b, e, f, h, j, g, i, *, k, l, m, n, o, #, t, s, r, q, p, &, x, y, z, u, v, w, }, alfabeto maiuscolo[] { $, A, D, B, E, F, H, J, G, I, *, K, L, M, N, O, #, T, S, R, Q, P, &, X, Y, Z, U, V, W, }; if(a >= A && a <= Z ) return alfabeto maiuscolo[a- A ]; else if(a >= a && a <= z ) return alfabeto minuscolo[a- a ]; else if(a == L à ) return alfabeto minuscolo[26]; else if(a == L À ) return alfabeto maiuscolo[26]; else if(a == L é ) return alfabeto minuscolo[27]; else if(a == L É ) return alfabeto maiuscolo[27]; else if(a == L è ) return alfabeto minuscolo[28]; else if(a == L È ) return alfabeto maiuscolo[28]; else if(a == L ì ) return alfabeto minuscolo[29]; else if(a == L Ì ) return alfabeto maiuscolo[29]; else if(a == L ò ) return alfabeto minuscolo[30]; else if(a == L Ò ) return alfabeto maiuscolo[30]; else if(a == L ù ) return alfabeto minuscolo[31]; else if(a == L Ù ) return alfabeto maiuscolo[31]; else return a;} int main(int narg, const char ** args) {if(narg == 1) return 1; ifstream is(args[1]); if(!is) return 2; streamsize q; is.seekg(0, ios::end), q = is.tellg(), is.seekg(0); char * buff = new char[q], c; is.read(buff, q), is.close(); string s(buff); istringstream iss(s); for(streamsize i=0; i!= q; ++i) iss.get(c), cout << PencaPolla(c);}