Newsgroup: it.comp.lang.c++
Titolo: Chi può spiegarmi cosa ha detto il mio prof?

Una frase come:
"Il C++ ANSI è un linguaggio molto debole dal punto di vista dei tipi,
per questo Java è migliore"
Che significa? Siete d'accordo?
Sapete farmi degli esempi?
--
Emanuele Di Saverio
---------------------------------------------
Remove NOSPAM manually for reply
Scusate le vaccate se  ne dico!

 Sapete farmi degli esempi?
no, se non ne illustri il contesto.
per me java e' molto piu' potente per il solo fatto di gestire la
garbage collection.
--
c.

 garbage collection.
Il fatto di gestire  la garbage collection non rende java un linguaggio di
per se piu' potente in assoluto; non in tutti i contesti puo' risultare
utile un meccanismo di garbage collection,anzi a volte puo essere anche
indesiderabile.
E poi la garbage collection e' un meccanismo che si limita alla gestione
automatica del rilascio di memoria occupata, non piu' referenziabile, mentre
l'approccio costruttore/distruttore del C++ e' un sistema che permette un
design piu' elegante e raffinato per la gestione razionale di qualsiasi tipo
di risorsa.

 Sapete farmi degli esempi?
Ti riporto un esempio tratto dal Lippman:
int intero = 0;
intero = 3.1415 + 3;
Che succede?
Succedono, implicitamente un sacco di cose:
viene eseguita l'operazione di somma tra un double (3.1415)
e un intero (3) nella quale la regola è di 'promuovere' il tipo più
piccolo (in questo caso l' 'int') in quello più grande (il 'double')
Per cui è come se stessimo facendo 3.1415 + 3.0
I risultato è 6.1415 ed è di tipo double.
A questo punto devo assegnare questo valore a 'intero' che
è di tipo 'int'.
In questo caso vale la regola che nell'assegnamento il termine
di destra, se possibile, viene convertito nel tipo di quello di
sinistra.
Quindi il 'double' viene convertito in 'int' (per troncamento) e quindi
alla fine la nostra variabile varrà intero==6.
Come vedi, i tipi sono sempre ben definiti ad ogni passaggio.
Aggiungo che le conversioni esplicite di tipo, in C++, si fanno
con gli operatori di cast:
static_cast<TIPO>(valore_da_convertire)
dynamic_cast<TIPO>(valore_da_convertire)
reinterpret_cast<TIPO>(valore_da_convertire)
const_cast<TIPO>(valore_da_convertire)
mentre è sconsigliato l'uso di cast in stile C
(TIPO)valore_da_convertire
o
TIPO(valore_da_convertire)
--
Gerolamo

 ...

sě per carita'. stavo infatti aggiungendo "peccato che dietro ci
vada tutto un ambaradan architetturale".
pero' mi sembrava un motivo un po' piu' forte che non i tipi di
dati.
quanto ai distruttori: per l'utilizzo efficiente occorre molta
esperienza. molta di piu' che non metterne e lasciare che
qualcuno ti svuoti la memoria.
--
c.

 qualcuno ti svuoti la memoria.
Ma quando quel qualcuno non sembra far bene il suo mestiere e ti ritrovi 
con un'applicazione il cui consumo di memoria continua a crescere, hai 
voglia l'esperienza che ci vuole per capire cosa succede e mettere a 
posto le cose. Ed e' un tipo di esperienza che generalmente non ci si fa 
fino a quando non ci si trova in una situazione critica.
Senza contare che esistono garbage collector per il C++.
Ciao,
Nicola

 per questo Java è migliore"
*molto* opinabile: se si escludono alcune conversioni implicite ereditate 
dal C il C++ ha un controllo dei tipi *molto* forte.
Ma la cosa piu` importatante e` forse un'altra: in un programma *ben* 
scritto in C++ il compilatore riesce a controllare a compile-time tutte 
le dipendenze *statiche* tra i tipi; al contrario in un programma "ben" 
scritto in Java le dipendenze statiche sono molto piu` "rilassate" e 
spesso occorre rimandare il controllo a run-time: la causa maggiore per 
questo comportamento e` la mancanza di un meccanismo per la 
programmazione generica in Java, ma il discorso rischia di farsi 
lungo...
ciao Anto
-- 
"Computer science is not about computers any more than astronomy
is about telescopes." -- EW Dijkstra

 dei tipi, per questo Java è migliore"
Sinceramente dovresti chiederlo al tuo prof, perché non è
molto chiaro. Se intende parlare del *controllo dei tipi* non
mi pare che il C++ sia molto debole, anzi... e Java, da questo
punto di vista (e neppure da altri, se non nella semplicità),
non mi pare per nulla migliore.
Ciao.
--
BSD is for UNIX-lovers -- linux is for Windows-haters.

Grazie a tutti per aver cercato di spiegare l'isnpiegabile!
--
Emanuele Di Saverio
---------------------------------------------
Remove NOSPAM manually for reply
Scusate le vaccate se  ne dico!
"Emanuele Di Saverio" <haz...@SPAMtiscalinet.it> wrote in message
news:ap49n5$gnl$2...@lacerta.tiscalinet.it...

Grazie a tutti per aver cercato di spiegare l'isnpiegabile!
cito da un vecchio manuale della Borland.
dunque il tuo prof sostanzialmente ha detto una cosa vera.
c++, al contrario di altri linguaggi di programmazione ad oggetti
(smalltalk), non ha un approccio ai tipi di variabile dinamico.
scrivendo una classe o una funzione si vorrebbe poterla
utilizzare per tipi diversi senza continuamente riclonare il
codice per far fronte a tutte le casistiche.
c++ pero' e' stato aggiornato facendo in modo di poter dichiarare
una classe senza specificare il tipo dei membri fino alla
definizione dell'oggetto di quella classe. idem per i parametri.
e' l'introduzione dei TEMPLATE, a consentire questa dichiarazione
"ritardata". i template fanno capo alla bozza ansi standard
ellis90.
il tuo prof ha ragione. si e' creata una sovrastruttura di classi
generiche che per diventare classi hanno sostanzialmente bisogno
di essere fornite dei tipi, mentre in altri linguaggi questo non
e' necessario (specie perche' a volte non viene fatto alcun
controllo sul tipo).
sicuramente ho fatto ancora piu' casino. ma come traccia puoi
prendere in considerazione: genericita', template, moduli
generici, moduli effettivi e classi contenitore.
ehia.
--
c.
--
c.
Salve raga, finalmente all'ovile a far le uova. Come state? Sono un po'
presa dagli studii oltre che dal lavoro per ora terminato. Vedo gente nuova
o sbaglio? Il bar un po' deserto nייי?????????   Che dire...si ricomincia?
Un bacione a tutti...
Roby

 volte non viene fatto alcun controllo sul tipo).
E dove sarebbe l'inferiorità di questo tipo di approccio?


E dove sarebbe l'inferiorità di questo tipo di approccio?
intuitivamente che mi devo creare un ambaradan di classi
generiche mentre negli altri linguaggi, dove non controllo il
tipo, ho un lavoro molto minore.
1. ogni professore tira l'acqua al proprio mulino
2. la qualita' del software dipende, in ultima analisi, dal
cervello dell'analista/programmatore.
io sto in mezzo.
c++ mi serve.
potendo scegliere mi leggo un fumetto. #faccina#
--
c.
Salve raga, finalmente all'ovile a far le uova. Come state? Sono un po'
presa dagli studii oltre che dal lavoro per ora terminato. Vedo gente nuova
o sbaglio? Il bar un po' deserto nééé?????????   Che dire...si ricomincia?


 tipo, ho un lavoro molto minore.
Cioe' stai dicendo che meno tipi ci sono meglio e'. Sei davvero convinto 
che questo sia quello che intendeva il prof. di Emanuele dicendo che il 
C++ ANSI e' inferiore al Java perche' e' "molto debole dal punto di 
vista dei tipi"?
Secondo me intendeva dire il contrario, anche perche' normalmente i 
termini forte/debole parlando di tipizzazione si usano per indicare 
rispettivamente maggiore/minore controllo sui tipi.
In entrambe le interpretazioni, pero', sono convinto che il prof. 
suddetto sia in errore.
Ciao,
Nicola

Nicola Musatti <Nicola....@ObjectWay.it> ...

forse non ci siamo molto capiti, anche perche' scrivo molto
meglio pl/sql che italiano.
SONO
D'ACCORDO.
#faccina#
--
c.
