Cari studenti,
auguri di buon anno a tutti!
Emanuele Panizzi
31 dicembre 2007
Buon 2008!
Posted by Emanuele Panizzi at 18:28 14 comments
30 dicembre 2007
Specifiche dell'esercizio per il progetto di Programmazione a oggetti
L'esercizio consiste nella progettazione di una serie di classi per modellare un sito web che ospita diversi blog e che avverta gli utenti della pubblicazione di nuovi post nei blog ai quali sono abbonati.
La progettazione deve seguire il design pattern Observer spiegato a lezione.
Durante l'esecuzione del programma saranno rappresentati da opportuni oggetti:
- i blog
- i post
- gli utenti abbonati (subscriber)
L'esercizio deve essere svolto in C++ e nel secondo linguaggio ad oggetti scelto dal gruppo; le specifiche indicate nel seguito devono essere seguite esattamente nella versione C++ e il più fedelmente possibile nel secondo linguaggio, adattandole dove le caratteristiche del linguaggio non permettano di seguirle alla lettera.
Specifiche
1) la classe Blog sarà derivata dalla classe subject descritta nel design pattern. Ogni oggetto della classe Blog sarà caratterizzato da un nome e da un elenco di post; per la versione C++ utilizzare un contenitore della standard library per l'elenco dei post.
2) la classe Blog metterà a disposizione un metodo pubblico NewPost() che permetterà di pubblicare un nuovo post specificandone autore, titolo e testo. Ogni volta che viene pubblicato un nuovo post, sarà invocato il metodo Notify() per permettere agli observer di aggiornare il proprio stato corrispondentemente alla variazione dello stato del blog.
3) lo stato del blog, costituito sostanzialmente dall'elenco dei post pubblicati, sarà rappresentato opportunamente nell'oggetto e sarà osservabile dagli observer invocando uno o più dei seguenti metodi pubblici della classe Blog:
GetName() che restituisce il nome del blog
GetTitle() che restituisce il titolo dell'ultimo post pubblicato
GetText() che restituisce il testo integrale dell'ultimo post pubblicato
GetLine() che restituisce i primi 10 caratteri del testo dell'ultimo post pubblicato
GetAuthor() che restituisce il nome dell'autore dell'ultimo post pubblicato
4) la classe Post sarà caratterizzata da tutti i dati relativi a un post, cioè: autore, titolo, testo. Si tratta di stringhe in tutti e tre i casi.
5) la classe Subscriber è una classe derivata dalla classe observer descritta nel design pattern; ogni oggetto della classe rappresenta un utente che si abbona ad uno o più blog per essere avvisato della pubblicazione di nuovi post; il subscriber è caratterizzato dall'indirizzo di posta elettronica; per effettuare l'abbonamento, si userà il metodo Attach() come descritto nel design pattern
6) poiché esistono subscriber generici e subscriber specifici, è opportuno derivare altre due classi dalla classe Subscriber: le chiamiamo SubsriberG e SubscriberS rispettivamente. Un subscriberG è interessato a tutti i post dei blog ai quali è abbonato, mentre un subscriberS è interessato solamente ai post scritti da un particolare autore;
6a) quando viene invocata la funzione Update() per un SubscriberG è necessario recuperare dal blog:
- il nome del blog stesso
- il titolo del post
- i primi 10 caratteri del testo
- il nome dell'autore
e stampare a schermo il subject e il body di una ipotetica email nella quale si informa l'utente della nuova pubblicazione, riportandone i dati sopra indicati;
6b) quando viene invocata la Update() per un SubscriberS è necessario:
- recuperare dal blog l'autore del post, e, se coincidente con l'autore scelto alla creazione del subscriber:
-recuperare nome blog, titolo post, testo integrale e mostrare a schermo il subject e body della mail ipotetica con questi tre dati
7) Nel main() vanno dichiarati un certo numero di blog e di subscriber generici e specifici, indicando per questi ultimi il nome dell'autore al quale sono interessati; vanno poi abbonati i subscriber ai vari blog; vanno infine creati alcuni post per verificare che i subscriber siano avvisati con le email opportune.
Note:
- la pubblicazione effettiva delle pagine web dei blog non va trattata
- sfruttare il polimorfismo per differenziare il comportamento del subscriber generico da quello del subscriber specifico.
- nomi degli autori, titoli e testi dei post sono da scegliere arbitrariamente ai soli fini dell'esecuzione del programma
Eventuali dettagli non specificati qui possono essere proposti in commenti a questo post. Inserire altresì nei commenti eventuali domande di chiarimento. Risponderò direttamente, ma invito anche gli studenti a rispondere ai commenti dei loro colleghi.
Posted by Emanuele Panizzi at 18:17 20 comments
28 dicembre 2007
Riferimenti volume GoF
Ecco i riferimenti del volume sui design pattern:
Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides
Design Patterns
Elements of Reusable Object-Oriented Software
ADDISON-WESLEY, 1995 (19-ma ristampa, Gennaio 2000)
ISBN: 0201633612
Nota: GoF
Posted by Emanuele Panizzi at 20:21 0 comments
Lezione di giovedì 17 gennaio
Lasciare un commento specificando se si è interessati a partecipare a questa lezione o a presentare il lavoro del proprio gruppo.
Posted by Emanuele Panizzi at 20:15 6 comments
Lezione di lunedì 14 gennaio
Lasciare un commento specificando se si è interessati a partecipare a questa lezione o a presentare il lavoro del proprio gruppo.
Aggiornamento di lunedì pomeriggio:
La lezione si è tenuta. Un gruppo ha descritto la realizzazione della parte C++ del progetto. Si è discusso sull'implementazione e sulle soluzioni adottate.
Un altro gruppo ha accennato al lavoro che stanno facendo con il linguaggio PHP, alle strutture del linguaggio utilizzate per realizzare l'esercizio e alle differenze con l'implementazione C++.
Non è stato possibile registrare l'audio della lezione.
Posted by Emanuele Panizzi at 20:14 11 comments
Lezione di giovedì 10 gennaio 2008
Lasciare un commento specificando se si è interessati a partecipare a questa lezione o a presentare il lavoro del proprio gruppo.
Posted by Emanuele Panizzi at 20:14 6 comments
Lezione del 7 gennaio 2008
Lasciare un commento specificando se si è interessati a partecipare a questa lezione o a presentare il lavoro del proprio gruppo.
Aggiornamento (5 gennaio 2008): ALLORA LUNEDI' FACCIAMO L'INCONTRO PER DISCUTERE DELLE DOMANDE CHE AVETE SUL PROGETTO. SI TERRA' REGOLARMENTE ALLE 14 NELLA SOLITA AULA.
Aggiornamento (7 gennaio):
[24 presenti]
Argomenti:
- domande e risposte sulla implementazione del pattern in C++
- uso di oggetti o di puntatori nei contenitori
registrazione audio dell'incontro
Posted by Emanuele Panizzi at 20:12 9 comments
21 dicembre 2007
Esercizio del progetto
Lezione del 20 dicembre 2007 - Ultima lezione del corso
[41 presenti]
Argomenti:
- pattern observer: approfondimento e considerazioni
- requisiti dell'esercizio da svolgere nei due linguaggi scelti per il progetto
- organizzazione per il mese di gennaio (incontri aggiuntivi ed esami):
- nel mese di gennaio è possibile fare 5 incontri nello stesso orario delle lezioni;
- lo scopo degli incontri è quello di approfondire gli argomenti del corso in relazione al progetto assegnato;
- negli incontri, i gruppi di studenti che stanno svolgendo il progetto, su base volontaria, presenteranno il lavoro svolto fino a quel momento; tale presentazione consentirà di effettuare una discussione utile a tutti gli studenti del corso; consentirà anche ai gruppi più attivi di avere una valutazione preventiva del proprio lavoro;
- inserirò nel blog 5 post, uno per ogni incontro; per poter svolgere la presentazione, o per partecipare come uditori, inserire un commento su uno dei post;
- gli incontri si terranno se e solo se ci sarà un numero sufficiente di uditori e almeno un gruppo presentatore; con un commento finale almeno 24 prima annuncierò se l'incontro si terrà o no;
- L'esame si terrà il 23 gennaio, mercoledì, alle 10:00 in aula riunioni a via salaria. Lo svolgimento è il seguente: chi non è esonerato dovrà fare uno scritto a risposta multipla (test) della durata di 20 minuti (15 domande), simile a quello della prova d'esonero; Poi iniziano le discussioni con i gruppi; la correzione dei test dei membri del gruppo non esonerati avverrà contestualmente alla discussione di ogni gruppo.
- Lo svolgimento del test e la discussione del progetto sono due cose distinte; un voto positivo in una delle due cose verrà 'salvato' per un anno nei miei file; chi non supera una delle due parti in questo appello potrà tornare a risostenerla nel prossimo appello; la discussione deve però essere svolta congiuntamente da tutti i componenti del gruppo in prima istanza: solo chi è eventualmente 'respinto' dovrà risostenere la discussione autonomamente in un appello successivo
Podcast della lezione:
registrazione audio della lezione
Posted by Emanuele Panizzi at 10:53 9 comments
18 dicembre 2007
Formazione dei gruppi
Coloro che cercano persone con cui formare un gruppo per il progetto possono lasciare un commento a questo post indicando:
- un proprio riferimento (es. email)
- se cercano un gruppo in cui inserirsi o se sono già in 2/3 e cercano un'altra persona
- se hanno già scelto un linguaggio (lasciando il commento nel post precedente) o se vorrebbero entrare nel gruppo che ha scelto un particolare linguaggio
Ogni linguaggio può essere scelto da uno e un solo gruppo.
Posted by Emanuele Panizzi at 12:32 13 comments
17 dicembre 2007
Design pattern
Lezione di lunedì 17 dicembre
[35 presenti]
Argomenti:
- assegnazione del progetto: spiegazione del post "Progetto"
- design pattern, accenni
- pattern: Observer
Podcast:
registrazione audio di questa lezione, in formato wav
Posted by Emanuele Panizzi at 17:52 4 comments
Polimorfismo
Lezione di giovedì 13 dicembre
[33 presenti]
Argomenti:
- funzioni virtuali
- late binding
- funzioni virtuali pure
- classi base astratte
- esempi
Ereditarietà
Podcast:
registrazione audio di questa lezione, in formato wav
Posted by Emanuele Panizzi at 17:42 0 comments
Progetto
Obiettivo del progetto:
conoscere un altro linguaggio di programmazione ad oggetti, analizzando le somiglianze e le differenze rispetto al C++.
Come svolgerlo:
- scegliere un linguaggio tra quelli indicati su wikipedia alla pagina Object-oriented programming language
- leggere la descrizione del linguaggio scelto su wikipedia stessa.
- approfondire la gestione di alcuni elementi del linguaggio, quali ereditarietà e polimorfismo, così come sono descritti nei siti web principali relativi al linguaggio scelto (i link a tali siti si trovano generalmente su wikipedia)
- realizzare un esercizio sia in C++ che nel linguaggio scelto: l'esercizio verrà assegnato in aula e riportato sul blog.
all'esame è necessario presentare una relazione sul lavoro svolto, sia su supporto cartaceo che digitale. Presentarsi all'esame con il computer portatile.
Discussione:
la discussione all'esame verterà sulle caratteristiche generali del linguaggio scelto paragonate a quelle del C++. Inoltre verrà analizzata l'implementazione dell'esercizio nei due linguaggi.
Gruppi:
di 3/4 persone. Non è necessario comunicare la composizione del gruppo in anticipo. E' necessario però scegliere il linguaggio di programmazione e indicarlo in un commento a questo post: verificare che non sia stato scelto da un altro gruppo prima!
Prenotazioni:
per sostenere l'esame è necessario prenotarsi via email con almeno una settimana di anticipo. Indicare nella mail il nome e cognome di tutti i componenti del gruppo.
Gennaio:
negli incontri di gennaio i gruppi che lo vorranno potranno descrivere il lavoro svolto ai fini di avere chiarimenti e indirizzi per la prosecuzione del progetto. Prenotare la descrizione inserendo un commento al post che inserirò appositamente.
Posted by Emanuele Panizzi at 13:05 30 comments
10 dicembre 2007
Sui template e i progetti multi-file
Notate quanto segue:
1) Quando utilizziamo i template nella definizione delle classi, il compilatore non compila effettivamente il codice della classe finché non è necessario.
Se ad esempio dichiariamo la seguente classe:
template
class Coppia
{private:
T1 primo;
T2 secondo;
public:
Coppia(T1,T2);
T1 Primo() const;
T2 Secondo() const;
};
questo codice verrà "conservato" dal compilatore finché non sia necessario compilarlo instanziando i due tipi T1 e T2, ad esempio a seguito dell'istruzione:
Coppia
2) Quando scriviamo un programma C++ siamo soliti dividerlo in più file per questioni di modularizzazione. Tipicamente, la dichiarazione di una classe sta in un file miaclasse.h, mentre la definizione delle sue funzioni proprie sta in un file miaclasse.cpp. Includeremo miaclasse.h in tutti i .cpp del progetto che usano oggetti di quella classe, oltre che in miaclasse.cpp.
3) Ma, se si tratta di una classe modello, cioè dichiarata mediante template, il compilatore non dovrà compilare i metodi definiti in miaclasse.cpp se nessuno li usa. E quindi, non avrebbe senso compilare separatamente il file miaclasse.cpp! (Nella compilazione separata, infatti, il compilatore "non ha memoria" delle compilazioni degli altri file del progetto, e non sa se in qualcuno di questi è stata usata la classe modello)
4) Quindi l'unica via praticabile è quella di includere tutta la classe modello in ogni file .cpp del progetto che vuole usarla. Pertanto (cosa che non si poteva evincere dal file che abbiamo realizzato nella lezione del 22 novembre, template.cpp) dobbiamo scrivere anche le definizioni dei metodi della classe modello in miaclasse.h. Il file miaclasse.cpp -- per le classi modello -- non dobbiamo scriverlo né inserirlo nel progetto.
5) Il linker è in grado automaticamente di identificare la implementazione di tutti i metodi della classe modello e di collegarli alle rispettive chiamate.
Nei file qui sotto potete trovare un esempio di programmino che compila e gira correttamente:
Posted by Emanuele Panizzi at 21:24 0 comments
Ereditarietà
Lezione di lunedì 10 dicembre, 1 ora
[33 presenti]
Argomenti:
- ereditarietàesercizio: conto ripetizioni caratteri in una parola
Ereditarietà
Podcast:
registrazione audio di questa lezione, in formato wav
Foto della lavagna:
Posted by Emanuele Panizzi at 20:17 0 comments
Esercitazione: blogger
Lezioni di: lunedì 3 dicembre, 1 ora e giovedì 6 dicembre, 2 ore
Argomento:
- Esercitazione su classi e contenitori. Tema dell'esercitazione:
- realizzare un programma per la gestione di un sito che pubblica dei blog.
- Ad ogni blog possono abbonarsi dei subscribers che riceveranno una mail ogni volta che verrà pubblicato un nuovo post sul blog.
- Modellare mediante opportune classi e metodi.
Podcast:
registrazione audio della lezione di lunedì 3, in formato wav
registrazione audio della lezione di giovedì 6, in formato wav
Codice scritto nelle due lezioni:
Posted by Emanuele Panizzi at 20:01 0 comments
Contenitori associativi
Lezione di giovedì 29 novembre
[36 presenti]
Argomenti:
- contenitori associativi: map, multimap, set, multiset
- esempio di uso del contenitore map
- esercizio: conto ripetizioni caratteri in una parola
Standard Library: contenitori, iteratori, algoritmi generici
Podcast:
registrazione audio di questa lezione, in formato wav
Codice scritto a lezione:
Posted by Emanuele Panizzi at 19:34 0 comments
03 dicembre 2007
Iteratori
Lezione di lunedì 26 novembre
Argomenti:
- iteratori
- esempio di uso del contenitore vector
Standard Library: contenitori, iteratori, algoritmi generici
Podcast:
registrazione audio di questa lezione, in formato wav
Codice scritto a lezione:
- codice:
Posted by Emanuele Panizzi at 12:59 4 comments
26 novembre 2007
Template, complessità, standard library
Lezione di giovedì 22 novembre
Argomenti:
- template
- template functions
- complessità: caso peggiore, caso medio, ammortata
- Standard Library: introduzione
- Contenitori
- Esempi contenitore list
registrazione audio di questa lezione, in formato wav
Codice scritto a lezione:
- codice:
Posted by Emanuele Panizzi at 08:37 4 comments
19 novembre 2007
Correzione in aula dell'esonero
Lezione di lunedì 19 novembre
[circa 50 presenti]
Argomenti:
- soluzioni del test
- scrittura, compilazione e run del programma
registrazione audio di questa lezione, in formato wav
Il test:
si trova qui
Risposte del test:
1c,2a,3b,4a,5a,6b,7b,8c,9c,10c,11b,12a,13d,14b,15b,16c,17c,18a,19a,20c,21c,22b,23a,24c,25b,26b,27b,28b,29a,30a
Il bonus:
Soluzione del programma bonus:
- codice:
Posted by Emanuele Panizzi at 16:06 3 comments
Risultati del test
L'esonero di giovedì scorso è stato svolto da 68 persone.
Ecco i risultati del test a risposta multipla. Ci sono stati 13 insufficienti, e la media è 21.46.
Chi è insufficiente (segnato in rosso) dovrà ripetere il test in sede d'esame.
Risultati test del 15/11/2007
Posted by Emanuele Panizzi at 09:18 6 comments
12 novembre 2007
Regole per l'esonero
L'esonero si svolgerà giovedì prossimo, 15 novembre, in aula 1 NEF (la solita), alle 16.
L'esonero è organizzato in due parti, di 40 minuti ciascuna, con un intervallo di pochi minuti (per ritirare la prima e consegnare la seconda parte).
Non è necessario iscriversi, chi è presente può partecipare.
L'esonero verte su tutti gli argomenti del programma svolti finora (capitoli 1, 2, 3 e 4 delle dispense).
Prima parte: TEST
La prima parte è un test a risposta multipla, su carta, si risponde barrando la risposta corretta.
Totale punti: 30, farà media con il voto del progetto.
Ogni domanda ha lo stesso peso.
Risposte sbagliate o non date valgono zero punti.
Durante il test:
E’ PROIBITO CONSULTARE LIBRI O ALTRO MATERIALE
E’ PROIBITO COMUNICARE CON ALTRE PERSONE PRESENTI O A DISTANZA
Seconda parte: BONUS
La seconda parte è un programma da scrivere al PC. E' cioè necessario utilizzare il laptop per compilare e provare il programma.
Durante il bonus:
E' POSSIBILE SVOLGERE IL PROGRAMMA CON ALTRE PERSONE
Al termine dei 40 minuti, è necessario consegnare il codice sorgente usando una penna usb (che verrà immediatamente restituita) o un supporto magnetico (che non verrà restituito).
Tutti i file vanno salvati in una cartella denominata <cognome>. Se l’esercizio è svolto in gruppo il nome della cartella è il cognome del primo partecipante (primo in ordine alfabetico). In questo caso, indicare sul file principale i nomi, cognomi e numeri di matricola di tutti i partecipanti.
Il bonus sarà valutato con un voto in trentesimi che, moltiplicato per 0.1, andrà a sommarsi al voto finale. Quindi il bonus può aumentare da zero a tre punti il voto finale.
Tutti i partecipanti a uno stesso gruppo del bonus prendono, ovviamente, lo stesso voto.
I gruppi che si formano per realizzare il bonus insieme sono estemporanei, e non hanno niente a che vedere con i gruppi che dovrete costituire per realizzare il progetto.
Posted by Emanuele Panizzi at 20:29 6 comments
Altro esercizio
Dichiarare e definire una classe C++ per la gestione di alberi binari, come descritto nel seguente Tipo di dato astratto. La classe deve evitare correttamente il fenomeno dell'interferenza.
TDA Albero
DOMINI: albero, intero, booleano
FUNZIONI:
creavuoto: ()-> albero // crea un albero vuoto
crea: (albero x intero x albero)->albero
// crea un nuovo albero dati due sottoalberi e il valore per la radice
sottoalberosin: (albero)->albero // restituisce il sottoalbero sinistro
sottoalberodes: (albero)->albero // restituisce il sottoalbero destro
radice: (albero)->intero // restituisce il valore della radice
IsEmpty: (albero)->booleano // restituisce true se l'albero è vuoto
Scrivere un main() che costruisce un albero leggendo 7 valori da tastiera e poi costruisce un nuovo albero speculare al primo. Infine stampa i due alberi in notazione parentetica, utilizzando una funzione apposita.
Es:
7
3 6
1 2 4 5
7
6 3
5 4 2 1
Stampa:
(7 (6 (5) (4)) (3 (2) (1)))
Chi risolve questo esercizio posti la sua soluzione come commento a questo post, così posso rispondere per fornire un aiuto, fare considerazioni, segnalare errori.
Posted by Emanuele Panizzi at 20:08 5 comments
Esercizio
Ecco il testo dell'esercizio della seconda parte dell'esonero dell'anno scorso (parte bonus).
N.B: l'anno scorso non avevo concluso il capitolo delle classi al momento dell'esonero, quindi l'esercizio non riguardava le classi. Quest'anno invece l'esercizio che proporrò richiederà anche la dichiarazione e definizione di una classe.
Si scriva un programma C++ che:
a) legga dieci valori int da tastiera e li memorizzi in un array v. I valori saranno forniti in ordine crescente.
b) Allochi un array w di dimensione n pari al numero di elementi differenti di v, e vi copi tali elementi.
c) Sostituisca ad ogni elemento w[i] la somma degli elementi w[i]+...+w[n-1] (MEDIANTE FUNZIONE RICORSIVA)
d) Chiami, per ogni w[i], la funzione int Sum(int* p) che sommi il valore w[i] ad un accumulatore interno e restituisca il totale t accumulato (DEFINIRE
e) Stampi v, w e t.
Ogni punto deve essere svolto realizzando almeno una funzione separata, chiamata dal main.
v, w e t devono essere dichiarate nel main.
Posted by Emanuele Panizzi at 19:58 2 comments
07 novembre 2007
Non c'è lezione domani!
A causa di un impegno istituzionale in dipartimento, domani (giovedì 8 novembre) non posso tenere la lezione.
Quindi il prossimo appuntamento è a ricevimento lunedì o sul blog, e poi all'esonero di giovedì 15.
Spiacente,
EP
Posted by Emanuele Panizzi at 18:55 4 comments
29 ottobre 2007
Calendario
Come avevo anticipato, ecco il calendario delle prossime lezioni:
- lunedì 5 novembre non c'è lezione
- giovedì 8 novembre: esercitazione
- lunedì 12 novembre non c'è lezione (sospensione per prove intermedie)
- giovedì 15 novembre: esonero
L'argomento della lezione di oggi conclude la parte di programma che sarà materia di esonero. Tutta questa parte è trattata nei capitoli 1-4 delle dispense.
Dopo l'esonero inizieremo il capitolo 5. Giovedì 12 novembre invece faremo un'esercitazione sugli argomenti del capitolo 4.
Posted by Emanuele Panizzi at 16:48 6 comments
Gestione della copia
Lezione di lunedì 29 ottobre, 1 ora
[>50 presenti]
Argomenti:
- interferenza
- passaggio per riferimento nel costruttore di copia
- copia profonda
- distruttore
- operatore di assegnazione
registrazione audio di questa lezione, in formato wav
Dispense:
Gestione della memoria: costruttore di copia, operatore di assegnazione, distruttore, interferenza
Vedi anche:
- codice aggiornato:
Posted by Emanuele Panizzi at 16:22 5 comments
Labels: copia profonda, costruttore di copia, distruttore, interferenza, operator=
25 ottobre 2007
Esercitazione: Lista
Lezione di giovedì 25 ottobre, 2 ore
[32 presenti, con 18 laptop]
Argomenti:
- Tipo di dato astratto
- implementazione delle funzioni del TDA mediante metodi C++
- restituzione valori o modifica degli oggetti
- elemento e lista: 2 classi?
- dichiarazione e definizione
- condivisione di memoria, side-effect, interferenza
Podcast:
registrazione audio di questa lezione, in formato MP3
Dispense:
Gestione della memoria: costruttore di copia, operatore di assegnazione, distruttore, interferenza
Vedi anche:
- codice:
Posted by Emanuele Panizzi at 19:12 1 comments
22 ottobre 2007
Costruttore di copia
Lezione di lunedì 22 ottobre 2007, 1 ora
[35 presenti]
Argomenti:
- costruttore di copia
- passaggio per riferimento costante
Dispense:
Gestione della memoria: costruttore di copia, operatore di assegnazione, distruttore, interferenza
Vedi anche:
- questi esercizi svolti:
Posted by Emanuele Panizzi at 20:07 0 comments
Metodi, parametri, overloading
Lezione di giovedì 18 ottobre 2007, 2 ore
[45 presenti]
Argomenti:
- definizione dei metodi
- operatore .
- compilazione, linking, dipendenze
- oggetto d'invocazione costante
- parametri per riferimento costanti
- overloading
Dispense:
Esempi; Overloading degli operatori
Podcast della lezione:
http://multicommunity.di.uniroma1.it/podcast/panizziC++20071018.wav
Vedi anche:
- questi esercizi svolti:
Posted by Emanuele Panizzi at 19:56 0 comments
Bando Percorso di Eccellenza
Vi informo che è aperto il seguente bando:
Bando Percorso di Eccellenza Lauree Triennali
Posted by Emanuele Panizzi at 19:27 0 comments
21 ottobre 2007
Domande su svolgimento lezioni, esonero, esami
In questo post e nei relativi commenti raccolgo le domande che mi arrivano per email le cui risposte potrebbero essere di interesse per tutti.
Invito chi ha domande su questi argomenti a farle commentando questo post anziché inviandomi una email direttamente. Ogni volta che viene inserito un commento mi arriva una notifica per email.
17 ottobre 2007
Avviso
Diffondo volentieri questa informazione, per chi fosse interessato:
Cari Amici,
come gia anticipato dal Magnifico Rettore nelle scorse settimane, la Sapienza ha bandito un concorso di idee sulla residenzialità per studenti.
L’obiettivo - al fine di interpretare adeguatamente i desideri degli studenti e rispondere alle loro esigenze con soluzioni fortemente innovative sia in termini di offerta di servizi sia in termini di qualità degli spazi - è acquisire suggerimenti e proposte per una residenzialità che non deve limitarsi a offrire il servizio alloggio, ma deve costituire lo strumento per un maggiore interscambio con i docenti, per attivare corsi di tutoraggio, per incentivare processi di socializzazione e infine per garantire adeguate condizioni di sicurezza: in altri termini deve agevolare gli studenti nel percorso formativo per consentire loro di laurearsi nei tempi prestabiliti, acquisire esperienze da spendere sul mercato del lavoro e incrementare la propria autonomia.
Il concorso è aperto agli under 30 ed è articolato in due sezioni: a) studenti b) laureati.
Possono partecipare studenti e/o laureati di qualunque Facoltà della Sapienza.
La scadenza è fissata per le ore 12 di lunedì 19 novembre 07.
Il testo del bando e la documentazione è disponibile sull’home page della Sapienza www.uniroma1.it
Considerato il significato dell’iniziativa, Vi prego di stimolare la più ampia partecipazione.
Vi ringrazio per la collaborazione e Vi saluto cordialmente.
Prof. Roberto Palumbo
Prorettore con delega per l'edilizia
Posted by Emanuele Panizzi at 09:57 0 comments
15 ottobre 2007
Oggetto di invocazione
Lezione di lunedì 15 ottobre 2007, 1 ora
[ho dimenticato di contare i presenti, a occhio più di cinquanta]
Argomenti:
- Analisi risultati del test svolto online; spiegazione domande e risposte
- Oggetto di invocazione
Dispense:
Classi
Podcast della lezione:
http://multicommunity.di.uniroma1.it/podcast/panizziC++20071015.wav
Vedi anche:
- questi esercizi svolti:
Posted by Emanuele Panizzi at 15:48 0 comments
Labels: oggetto d'invocazione
Risultato test online
Come si può vedere, il risultato non è completamente incoraggiante. Consiglio di confrontare con le proprie risposte, e approfondire gli argomenti su cui avete fatto errori.
Le risposte corrette le ho segnate in rosso. Le risposte più quotate sono segnate in grassetto.
La domanda 3, in cui la risposta più data non è quella corretta, è la più preoccupante!
Per le altre domande, spesso la percentuale di risposte sbagliate è davvero alta!
| |
|
1. int cubo(int x); | |||
Response Percent | Response Count | ||
x per valore, ritorno per valore | 76.7% | 33 | |
x per riferimento, ritorno per valore | 14.0% | 6 | |
x per valore, ritorno per riferimento | 4.7% | 2 | |
x per riferimento, ritorno per riferimento | 4.7% | 2 | |
answered question | 43 | ||
skipped question | 0 |
2. Per cambiare il segno di una variabile int mediante una funzione la cui chiamata nel main è la seguente: CambioSegno(i); l’intestazione della funzione deve essere: | |||
Response Percent | Response Count | ||
void CambioSegno(int x); | 19.1% | 8 | |
void CambioSegno(int& x); | 66.7% | 28 | |
int CambioSegno(int* px); | 14.3% | 6 | |
answered question | 42 | ||
skipped question | 1 |
3. Il parametro attuale a in: main() { int a; f(a); } è passato: | |||
Response Percent | Response Count | ||
per valore | 52.4% | 22 | |
per riferimento | 0.0% | 0 | |
non si può stabilire senza guardare la dichiarazione della funzione | 47.6% | 20 | |
answered question | 42 | ||
skipped question | 1 |
4. In questo programma: void f(int val, int& rif) { val++; rif++; } main() { int i = 1; int j = 1; f(i,j); cout <<> | |||
Response Percent | Response Count | ||
1 1 | 7.1% | 3 | |
1 2 | 78.6% | 33 | |
2 1 | 4.8% | 2 | |
2 2 | 9.5% | 4 | |
answered question | 42 | ||
skipped question | 1 |
5. Si consideri il passaggio del parametro nel seguente programma: void f(int* v) { // ... } main() { int v[1000]; f(v); } Si tratta di: | |||
Response Percent | Response Count | ||
passaggio per valore dell’array v | 5.0% | 2 | |
passaggio per valore del puntatore alla prima locazione dell’array | 60.0% | 24 | |
passaggio per riferimento dell’array | 12.5% | 5 | |
pass per riferimento del puntatore alla prima locazione | 22.5% | 9 | |
answered question | 40 | ||
skipped question | 3 |
6. Questa funzione: int* f() { int l; // ... return &l; } | |||
Response Percent | Response Count | ||
è corretta | 22.5% | 9 | |
crea un errore a runtime perché l’indirizzo restituito al chiamante non esiste più | 30.0% | 12 | |
rende il programma imprevedibile perché il contenuto della locazione puntata può essere cambiato | 47.5% | 19 | |
answered question | 40 | ||
skipped question | 3 |
7. void f(int*& p) { p++; } | |||
Response Percent | Response Count | ||
corretta, modifica il parametro attuale | 47.5% | 19 | |
corretta, incrementa l’oggetto puntato dal parametro attuale | 35.0% | 14 | |
errata | 17.5% | 7 | |
answered question | 40 | ||
skipped question | 3 |
8. delete p; | |||
Response Percent | Response Count | ||
dichiara libera la locazione di memoria puntata da p | 87.2% | 34 | |
cancella il contenuto della locazione puntata da p | 7.7% | 3 | |
cancella il contenuto del puntatore p | 5.1% | 2 | |
answered question | 39 | ||
skipped question | 4 |
9. int* v = new int[100]; Data questa dichiarazione si può affermare che v[0] e *v: | |||
Response Percent | Response Count | ||
sono equivalenti | 72.5% | 29 | |
indicano rispettivamente un int e un puntatore | 17.5% | 7 | |
sono equivalenti, ma la seconda è sconsigliabile | 10.0% | 4 | |
solo la seconda è corretta | 0.0% | 0 | |
answered question | 40 | ||
skipped question | 3 |
10. In questa funzione, il cui scopo è quello di allocare un array di 100 elementi interi e associarne l'indirizzo della prima locazione al parametro attuale: void Alloca(...p) { p = new int[100]; } i puntini di sospensione vanno sostituiti con: | |||
Response Percent | Response Count | ||
int* | 37.5% | 15 | |
int& | 12.5% | 5 | |
int*& | 42.5% | 17 | |
nessuna delle precedenti | 7.5% | 3 | |
answered question | 40 | ||
skipped question |
Posted by Emanuele Panizzi at 12:59 0 comments