Newsgroup: it.comp.lang.c
Titolo: Esempi di C++

Salve a tutti. Ho letto in rete una breve introduzione alla programmazione
ad oggetti, ma non ho esattamente capito quali sono gli effettivi benefici
della programmazione ad oggetti... Qualcuno potrebbe indicarmi qualche
programmino (piccolo e facile da capire) in C++ ?
-- 
*** Gottardi Matteo / 
goma...@tin.it
 ***
*Linux*, the choice of a _GNU_ generation

programmino (piccolo e facile da capire) in C++ ?
I benefici dell'impostazione ad oggetti in quanto tale sono piuttosto 
associati a programmi NON piccoli.  Comunque, in associazione
con la programmazione "generica" (template), e' possibile mostrare
un programma che e' in effetti "piccolo e facile da capire" in C++
Standard (per chi *conosca* il C++ Standard e le sue librerie,
ovvio; nessun programma e' facile da capire, per quanto piccolo,
se e' in un linguaggio che non si conosce bene!), mentre non lo
sarebbe senza queste facilities.  Si tratta, in pratica, di mostrare
quanto la programmazione puo' essere facilitata usando librerie
ben fatte di classi e template -- l'impostazione a oggetti e generica
e' naturalmente quella che permette piu' agevolmente di fare dette
librerie (che di per se' sono grosse e complicate!).
Prendiamo ad esempio il classico problema di scoprire quali
sono le 10 parole piu' frequenti di un testo.  In C++ Standard,
si potrebbe scrivere qualcosa del genere:
// anzitutto, richiediamo un tot di funzionalita' standard
// della libreria; questo e' il tipo di cose che normalmente
// vanno negli "header precompilati" di un progetto:
#include <iostream>        // semplice I/O standard
#include <iomanip>          // formati di I/O
#include <string>              // stringhe di caratteri
#include <map>                // array associativi
#include <vector>             // array normali
#include <algorithm>        // algoritmi vari
using namespace std;      // importiamo i nomi
// poi, definiamo i "nostri" tipi e relative funzioni d'appoggio;
// qui, non vale la pena di fare una nostra class con i suoi
// metodi ecc ecc, basta dare un nome comodo a tipi gia'
// forniti dalle librerie standard:
typedef pair<string,int> coppia;
typedef vector<coppia> cvet;
// e fornire una funzione di confronto per il sort, e una
// di stampa formattata per l'emissione dei risultati:
inline int confronta(const coppia& a, const coppia& b) {
    // diamo priorita' all'int (conteggio), ma se esso e'
    // eguale sortiamo alfabeticamente come secondario:
    if(a.second == b.second)
        return a.first > b.first;
    // conteggio non eguale, quindi ha priorita'
    return a.second > b.second;
}
inline void emetti(const coppia& c) {
    // un qualsiasi formato leggibile e chiaro per
    // emettere una coppia conteggio/parola:
    cout << setw(6) << c.second;
    cout << setw(0) << " " <<
        c.first << "\n";
}    
// infine, il nostro programmino che usa questi costrutti:
int main()
{
    // immettiamo tutto standard-input e contiamo le
    // occorrenze di ogni parola in un array associativo
    // parola->intero:
    map<string,int> conto;    // l'array associativo
    string parola;                   // parola corrente 
    while(cin >> parola)
        ++conto[parola];
    // riversiamo il conteggio in un array "liscio"
    // a standard, dovrebbe bastare:
    // cvet risult(conto.begin(), conto.end());
    // ma se il compilatore non supporta pienamente
    // lo standard puo' invece occorrere questo...:
    cvet risult;
    copy(conto.begin(), conto.end(),
        back_insert_iterator<cvet>(risult));
    // sortiamo l'array dei risultati
    sort(risult.begin(), risult.end(), confronta);
    // emettiamo i 10 migliori risultati su standard output
    for(int i=0; i<10; ++i)
        emetti(risult[i]);
    // fine del programma
    return 0;
}
Naturalmente, trattandosi appunto di un programma piccolo,
la potenza dell'OO e della programmazione generica non
risalta pienamente; un programma analogo sarebbe fattibile
con linguaggi o librerie che abbiano qualche forma "built-in"
di stringhe, array associativi, e sorting arbitrari, ovvero, anche
ad esempio in C, reimplementandosi una limitata forma di
questi costrutti per quel sottoinsieme di funzionalita' che ci
serve agli specifici scopi del programma.  OO e generics
permettono tuttavia di costruire, in modo ragionevolmente
agevole (non "facile" -- ma, meno difficile che senza questi
strumenti), librerie estremamente ricche, complicate, e potenti,
senza le limitazioni dovute a quanto sia gia' "built-in" in un
dato linguaggio, e senza doversi reinventare la ruota ogni volta.
Alex


Mamma mia!!! E pensare che io ho sempre scritto 10M i righe di prog. :-((
Grazie
P.S: sono ancora sconvolto :-)
Emanuele Cesena
d.a.m...@iol.it
ICQ n° #10570672
"Il proiettile in arrivo ha diritto di precedenza"

Come fa a "capire" che ci riferiamo all'int??
Cosi' e' definito l'operator[] che stiamo applicando: ritorna
un reference a quel dato int (piu` in generale, in una
map<A,B>, operator[] prende un argomento constA&
e ritorna un B&).  Se l'int cui facciamo riferimento non
esisteva ancora (cioe' la prima volta che incontriamo una
certa parola), viene generato con il costruttore di default,
che, in C++ Standard per i tipi built-in, come int, e` definito
nello stesso modo dell'inizializzazione di dati statici privi
di inizializzatori espliciti (quindi, zero).
Alex

di inizializzatori espliciti (quindi, zero).
Ahh... ora sembra quasi chiaro.
Ti ringrazio infinitamente... cercherò un buon compilatore (buono anche nel
prezzo, cioè gratis :-) )
Ciao


prezzo, cioč gratis :-) )
egcs, che trovi a 
www.cygnus.com
, e' buono e gratuito; la
sua aderenza allo standard e', in particolare, assai discreta,
soprattutto nelle ultimissime versioni.  Puo` essere integrato
con Windows32 attraverso (almeno) due diversi ambienti,
il grosso "Cygwin32" della Cygnus stessa (che emula un
mucchio di funzionalita` di tipo Unix), oppure il piu` "povero
ma snello" "Mingw32" (sul sito Cygnus dovresti trovare i
relativi puntatori).
Come libro di testo, se appena appena mastichi l'inglese,
suggerisco ENTUSIASTICAMENTE la versione beta di
"Thinking in C++ 2nd Edition" di Bruce Eckel, gratuitamente
scaricabile (a scelta RTF, testo ASCII, o sperimentale forma
HTML) da 
www.bruceeckel.com
.  E' una beta, quindi con
"lavori in corso", ma eccellente -- e gratuita.
Alex


Mmm... io e l'inglese non siamo grandi amici, comunque posso sempre provare
a darci un'occhiata!! :)
Ciao e grazie ancora
