Newsgroup: it.comp.lang.c++
Titolo: Lippman vs. Stroustrup

Salve,
Dovendo acquistare un libro di C++, quale mi consigliate fra "C++
Primer" e "The C++ Programming Language"?
Tenete conto che ho gia' la versione italiana della seconda edizione
del Lippman (e non mi e' piaciuta molto, ma probabilmente e' colpa
della traduzione), e sono interessato soprattutto alle novita'
apportate dallo standard ANSI/ISO, prime fra tutte le nuove librerie
standard.
In particolare mi piacerebbe sapere quale dei 2 libri e'
- migliore come reference
- migliore come tutorial
- piu' completo e approfondito
Ringrazio in anticipo,
-- 
d i e g o
--
Per le repliche elimina dal mio indirizzo le cifre e le `x'


Premetto che la seconda edizione del Lippman fa riferimento ad
una versione del linguaggio ormai datata,
in cui, ad esempio, le eccezioni erano considerate
ancora "lavori in corso", e ad esse viene dedicata solo una appendice.
Io mi sentirei di consigliare lo Stroustrup come riferimento
completo ed approfondito. Stroustrup non ha la pretesa di insegnare
il linguaggio, ma solo di presentarlo in tutte le su peculiarita'.
Se sai gia' il C++, allora lascia Lippman per chi deve ancora impararlo.
--== Sent via Deja.com 
http://www.deja.com/
 ==--
---Share what you know. Learn what you don't.---

 Primer" e "The C++ Programming Language"?
Per sentito dire da esperti di questo ng, il migliore dovrebbe essere
Lippman e Lajoie "C++ Primer" non ricordo l'edizione. Assicurati che sia
l'ultima.
EMG

- piu' completo e approfondito
????
Dipende da quali punti di vista...
Comunque eventualmente ti servisse un libro introduttivo, ma
completo... scaricati quello di bruce eckel, non e` ancora completo, ma
e` molto valido (
www.bruceeckel.com
)
Saluti,
Paolo
-----------------------------------------------------------------
  Paolo Marotta
  Computer Science, University of Pisa
  home:   
http://www.cli.di.unipi.it/~marotta
-----------------------------------------------------------------


Addison Wesley editori.
Se è un principiante Lippman va benissimo (io almeno mi ci trovo bene), ma
lo stesso Lippman dice che chi conosce il linguaggio dovrebbe far
riferimento a testi che scendono più in profondità.

In realta' temo che ti farebbero comodo entrambi. Il Lippman e' meglio
come tutorial, in generale e' scritto in modo piu' chiaro, ma e' scomodo
come reference e mancante degli aspetti piu' approfonditi: certi
dettagli li trovi solo sullo Stroustrup. Per contro l'organizzazione
dello Stroustup non mi e' particolarmente congeniale, perche' troppo
spesso richiede di saltare da una parte all' altra per trovare tutto
quello che serve su un argomento. Viene da chiedersi poi' che ci stiano
a fare le elucubrazioni dell'autore su problematiche filosofiche quali
design, ecc. Ti diro' che avendoli a disposizione tutti e due, piu'
volte mi sono trovato a leggere un argomento prima su uno poi sull'altro
e quindi a desiderare di averne un terzo...
Ciao,
Nicola

design, ecc.
Aspetti di questo tipo sono fondamentali per capire le idee che stanno alla
base di un linguaggio e giudicare quando e come usarlo.
La scelta di un linguaggio non e` semplicemente questione di gusti, ma e`
inanzi tutto dettata da esigenze obiettive del compito che si vuole
risolvere.


l'ultima.
L'ultima e' la terza, disponibile solo in inglese AFAIK (ma questo non deve
rappresentare un problema per il programmatore C++).
Davide Marcato.
----------------------------------------------------
| -- Freelance International Consultant
| -- Win32/MFC/COM Development & Training
| -- Technical Writer & Speaker
----------------------------------------------------
| -- Email: 
mar...@programmers.net
| -- Web: 
http://www.DavideMarcato.com
----------------------------------------------------

Vero. Resta il fatto che B.S. avrebbe potuto scrivere due libri, uno sul
linguaggio ed uno su OOD in C++, guadagnando di piu' lui e, a mio
avviso, centrando meglio gli interessi di specifici lettori. Tra l'altro
"The C++ Programming Language" non e' proprio un libro adatto come
tutorial.
Personalmente poi penso che ci siano altri autori piu' efficaci di
Stroustrup nel presentare gli aspetti concettuali dell'orientamento agli
oggetti; lo stesso C++ mi pare, per quanto divertente da usare e
certamente potente, un linguaggio piuttosto contorto.
Nicola Musatti

 
Dai consigli che ho ricevuto finora penso proprio che faro' cosi'.
Grazie a tutti per le risposte, 
Ciao,


certamente potente, un linguaggio piuttosto contorto.
Molto probabilmente nel C++ di cose che non vanno molto bene
ne esistono, ma il suo modello di OOP (escludendo i template)
non mi sembra poi cosi` contorto.


non mi sembra poi cosi` contorto.
Forse, quello che risulta più difficile è distinguere le caratteristiche nel
loro insieme da quelle strettamente ad oggetti. Poiché il linguaggio non
impone a priori un paradigma ma ne supporta almeno tre (strutturato,
orientato agli oggetti e programmazione generica) con i relativi stili e
idiomi, è inevitabile che, nell'insieme, il quadro sia piuttosto complesso.
Se poi non si è molto afferrati in tutti questi approcci diversi, non si è
magari nemmeno in grado di capire dove finisce l'uno e dove inizia l'altro,
arrivando alla conclusione che certi "giri" sono davvero contorti.
Ad esempio, ultimamente, mi sono trovato a discutere con qualcuno di oop e
ne è uscito fuori che spesso il riuso tanto decantato dall oop non è
realizzabile per colpa dei template e di STL. Non so se rendo...
:o)
Ciao
Andrea

realizzabile per colpa dei template e di STL. Non so se rendo...
Premesso che uso raramente i template (li trovo utili per poche cose),
che cosa di essi crea problemi?


 magari tenendoti su un piano non strettamente tecnico?
Se ho capito bene, l'amico intende dire che i template e l'STL, essendo
il supporto del C++ alla programmazione generica, non c'entrano un tubo
con la OOP.
EMG

 che cosa di essi crea problemi?
Gli aspetti che trovo piu' noiosi sono i seguenti:
primo, l'impossibilita' di verificare prima dell'istanziazione se la
classe parametro attuale del template soddisfa eventuali requisiti, ad
es.:
template <class C> class Generica {
	public:
		Generica(C & c) : obj(C) {}
		agisci() { obj.fai(); }
	private:
		C & obj;
};
class Specifica {
	public:
		noNonFaccio() {}
};
main() {
Specifica s;
Generica<Specifica> g(s);
	g.agisci();  	// non puo' funzionare perche Specifica non
			// implementa il metodo fai
}
Sarebbe bello poter dire qualcosa come:
class Interfaccia { fai() };
template <class C : Interfaccia> class Generica {
	...
	agisci() { obj.faiDavvero(); } // Non valido perche' Interfaccia
					// non specifica faiDavvero
	...
};
class Specifica {...};
Generica<Specifica> g; 	// Non valido perche' Specifica non eredita da
			// Interfaccia
Secondo, se il compilatore non supporta un meccanismo di precompilazione
degli header i tempi di compilazione si allungano a dismisura: ad es. in
un progetto realizzato con il Borland C++Builder 4 il passaggio all'uso
di header precompilati (per altro implementati in modo un po' primitivo)
ci ha permesso di ridurre a un quarto il numero di linee compilate, ed i
tempi di conseguenza
Nicola Musatti