Newsgroup: it.comp.programmare
Titolo: Perche tanti linguaggi?

Salve, ho un dubbio che ho in testa da quando conosco il significato della
parola "programmazione", perche esistono tanti linguaggi come ad esempio C++
/Basic /Pascal 
ecc.ec
..
di questi la sintassi di base mi sembra abbastanza simile, allora cosa è che
differenzia due linguaggi?
grazie per le risposte
Ciao Ciao
Fiz

 differenzia due linguaggi?
C++, Basic, Pascal sono tre :)
Cmq.... il basic è un linguaggio per principianti, che permette la creazione
di piccole applicazioni e non è molto usato ormai. Il pascal è soprattutto
usato a scopo didattico data la presenza dei costrutti fondamentali e visto
che non è troppo facile ne troppo complesso (una via di mezzo tra BASIC e
C++). Il C++ è un linguaggi che deriva dal C. Esso è il più potente e
completo dei 3 (e credo di tutti gli altri del suo genere) infatti la
maggior parte delle applicazioni sono scritte in questo linguaggio.
Ovviamente è molto più complicato e per poterlo studiare in genere è
consigliata la conoscenza di un altro linguaggio simile, anche se cmq si può
cominciare direttamente dal C++ studiando solo le parti più semplici, per
poi entrare nel cose più difficili. Il motivo dell'esistenza di molti
linguaggi nasce dal fatto che ci sono molte software house e anche perché
generalmente per ogni compito un linguaggio è più indicato di un altro (ad
es. anche se il C++ è il più potente non significa che delle applicazioni
più leggere non debbano essere scritte in Pascal o Java). Proprio Java ha
una sintassi simile a C++ ma è più lento (perché compila sono a livello di
byte code, e quindi ha bisogno di un'emulatore su ogni macchina in cui deve
girare) ma comunque offre possibilità per sviluppare applicazioni per il web
(come applet) che in C++ ti sogni.
Prima di scegliere quale linguaggio studiare, scegli in quale campo
dell'informatica vuoi fare strada.
ciao
Luigi

 andava bene per tutto.
Java è un linguaggio che credo farà molta strada perché è molto moderno e se
non sbaglio ho letto alcuni articoli del suo utilizzo per la PS-X 2 e nei
cellulari(forse ricordo male), però considerarlo un linguaggio veloce mi
sembra assurdo. I vantaggio fondamentale è che non essendo compilato, gira
su ogni macchina a prescidere dall'hardware e dal sistema operativo (ma
questo perché c'è l'emulatore ti JVM di windows, se no...).
Che linguaggio hai scelto?
Conosci Python?
ciao

 C++, Basic, Pascal sono tre :)
era "due linguaggi" inteso in senso generale non riferito a quelli di prima
;)

differenzia due linguaggi?
La tua domanda non è molto diversa dal chiedere perché ci sono diversi
modelli di automobili.
I vari linguaggi sono nati in epoche diverse e con scopi diversi (e
anche creati da persone con gusti diversi!). Fra questi linguaggi è
qundi opportuno scegliere il più adatto ai tuoi scopi (o quello che è
invece richiesto sul posto di lavoro che magari non è però il +
adatto).
Per quanto riguarda la sintassi è ovvio che sia simile poiché i
linguaggi derivano le loro carateritiche da altri, nessun linguaggio è
innnovativo al 100% (giusto, perché buttare ciò che funziona bene?);
la sintassi è comunque la parte - importante di un linguaggio, alla
fine in tutti trovi + o - le stesse cose come if, while e così via.
Ha invece un'importanza notevole la presenza di librerie che fanno
parte del linguaggio stesso (non so spiegarmi meglio, nel senso che
sono parte integranete del linguaggio e non librerie esterne
distribuite separatamente).
Marco Barisione (ICQ 84277092)

 distribuite separatamente).
Le librerie sono sostanzialmente un'insieme di funzioni che servono per i
più svariati scopi.
Ad es. C++ offre la libreria math che contiene alcune funzioni matematiche
come ad es
pow (x, y)
che calcola la potenza di x ^ y. Se tu devi scrivere un programma che
calcola la potenza tra 2 numeri, in C++ fai uso della funzione di libreria e
risolvi il problema, mentre in Pascal e in Basic devi scriverti tu una
funzione che faccia questo. C++ offre talmente tante funzioni di libreria
che riducono notevolmente il tempo di sviluppo.
Ciao
Luigi

che riducono notevolmente il tempo di sviluppo.
Dire che C++ ti permette di ridurre i tempi di sviluppo in confronto a
basic e pascal è una fesseria. Qualsiasi ambiente che usa C++ ha tanti
pregi, ma non certo quello di essere veloce come Delphi o Visual Basic
nei tempi di sviluppo. :-)
-- 
So I dub thee Unforgiven.

 come ad es
questo č sostanzialmente inesatto. Il C++ offre una libreria standard; tra 
le funzioni disponibili nella libreria standard ce ne sono alcune i cui 
prototipi sono dichiarate nell'header <cmath> o <math.h>; perň math non č 
una libreria a sé stante.
Anto
-- 
Antonio Cuni, 19 anni, studente
Brainbench C++ Master: 4.6, higher than 98% of all previous test takers.
C Language: 3.32, higher than 79% of all previous test takers.
Guida C/C++ di Programmazione.it: 
http://cpp.programmazione.it

orientato???
Arrivo anch'io a farne gli elogi visto che ormai su questo ng faccio
solo questo.
python è un linguaggio molto semplice da imparare ma anche molto
potente orientato agli oggetti.
E` un linguaggio di scripting quindi è interpretato (per questo è +
lento ma non necessita di essere ricompilato di continuo).
Visto che conosci java può interessarti jython, cioè python realizzato
completamente in java che offre le stesse caratteristiche del
linguaggio implementato in c (tranne alcune per limitazioni di java) e
in + puoi accedere ale librerie java.
se vuoi + informazioni puoi provare su:
www.python.org
 [inglese]
python.penguin.it
 [italiano]
o sui newsgroup:
comp.lang.python [inglese]
free.it.python [italiano]
Marco Barisione (ICQ 84277092)

 orientato???
E' un linguaggio di scripting che però è a oggetti ed è potente come Perl, 
se non più, ma è più semplice anche sintatticamente. Inoltre esiste Jython, 
che permette di fare ciò che fai in Java utilizzando anche le sue librerie, 
ma con la sintassi Python, quindi imparando Python puoi fare anche Applet 
etc...
Putroppo essendo interpretato non è velocissimo, però tutto sommato l'ho 
studiato un po, anche se adesso l'ho lasciato per studiare altro (ASM ad 
es. che ancora sto cercando un buon libro in ITA).
vai su 
www.python.org
 e vedrai cosa offre.
ciao
-- 
Luigi
--
bug windows [5] = {"95", "98", "NT", "Me", "2000"};
togli "tilescarpe" per rispondere via e-mail

 prototipi sono dichiarate nell'header <cmath> o <math.h>; perň math non č
Va be, io intendevo math.h... era per dare l'idea no? Non credo che chi non 
sa la differenza tra 2 linguaggi possa sapere perché esiste math.h e cmath


 pregi, ma non certo quello di essere veloce come Delphi o Visual Basic
Umh.... se devi scrivere un programma dove si fa un uso massiccio di 
template, come fai in Delphi o Visual Basic?
Riscrivi le funzioni per ogni tipo?


 nei tempi di sviluppo. :-)
Qui non si parlava di ambienti di programmazione. Prova a utilizzare delhi(o
meglio in questo caso si dovrebbe parlare di Object Pascal) e il basic senza
il supporto dei framework, e senza l'ambiente RAD messo a disposizione, e mi
sa che ci metti almeno quanto il c++, poi se il progretto č ampio non ne
parliamo...

 differenzia due linguaggi?
Devi sapere che esistono diversi paradigmi di programmazione, il primo che 
è stato implementato è il paradigma imperativo, poi sono venuti 
quelli logici, funzionali, object-oriented, object-based ...
Devi sapere che nella programmazione esistono diversi paradigmi.
Il primo che è stato implementato è stato quello imperativo, 
successivamente sono venuti fuori i logici, i funzionali, 
gli object-oriented, gli object-based...
Le tecniche di programmazione per i vari paradigmi sono completamente 
diverse tra loro !
Hanno ragione gli amici che dicono che java è più lento di altri linguaggi
, del C ad esempio, però non tengono conto della potenzialità di 
questo linguaggio, fortemente tipato, gestione automatica delle eccezzioni
e di garbage, polimorfismo, overloading, no puntatori, ecc...
Sono tutti aspetti che caratterizzano un linguaggio moderno e sicuro.
Quando si programma per la rete, poi la sicurezza è fondamentale !
Solo il fatto di una gestione nobilitata dei puntatori(tramite gli oggetti), 
garantisce di non lavorare sulla memoria e programmare ad un livello 
di astrazione molto superiore rispetto al C, che è al livello subito 
dopo l'Assembler. 
Spero di averti chiarito le idee...
bye

 Va be, io intendevo math.h... era per dare l'idea no? 
si, ma un'idea sbagliata :-)


 si, ma un'idea sbagliata :-)
Ma può essere sbagliata dal punto di vista tecnico... in questo conta il
concetto.
ciao

 oggetti), garantisce di non lavorare sulla memoria 
ti consiglio di leggerti l'articolo di Carlo Pescio sul numero 12 di C++ 
Informer (
www.eptacom.net
). Da quello risulta abbastanza chiaro come la 
gestione semplificata della memoria proposta da Java complica terribilmente 
la gestione di tutte le altre risorse. Se vuoi posso essere un po' più 
esplicativo.
Ciao Anto


 
Mi farebbe piacere ...

 concetto.
in un newsgroup di programmazione si parla di cose tecniche, no? Cmq direi 
di finirla qui, mi sembra una discussione un po' inutile...


 Mi farebbe piacere ...
allora, prima di tutto in quell'articolo Pescio fa notare che in C++ è 
molto usato un concetto noto come "Resource acquisition is initialization": 
in pratica le risorse vengono acquisite nel costruttore di una classe 
apposta e vengono rilasciate nel distruttore di quella stessa classe; ad 
esempio:
// C++
void f()
{
  ofstream file("pippo.txt");
  // operazioni su file
}
Nota che non è necessario aprire il file né, tantomeno, chiuderlo. Il succo 
della questione sta nel fatto che se, per caso, viene sollevata una 
eccezione all'interno del blocco "operazioni su file" il file viene sempre 
e comunque chiuso, dato che il C++ garantisce che il distruttore di file 
viene chiamato sempre e comunque in un *ben determinato* momento.
In Java non è possibile fare una cosa del genere, perché la presenza del 
garbage collector non garantisce nulla riguardo al momento in cui viene 
richiamato il distruttore. Quindi in Java bisogna, per forza di cose, 
rinunciare al concetto chiave in C++ di "resource acquisition is 
initialization".
Rinunciando a questo concetto è necessario gestire manualmente tutte le 
operazioni di acquisizione/rilascio di risorse che non siano la memoria: 
Pescio afferma che "Java ha barattato la complessità nella gestione della 
memoria con la complessità delle gestione di *tutte* le altre risorse". 
L'uso della clausola finally semplifica leggermente le cose, ma ciò non 
toglie che la responsabilità ricade sul programmatore in ogni caso (e 
questo non è un bene).
Cmq ti consiglio di leggerti il suo articolo, che è scritto molto bene e 
presenta anche degli esempi di codice. Per qualsiasi altra info dimmelo che 
sono qua...


template, come fai in Delphi o Visual Basic?
ma soprattutto, che diavolo sono i template?

poi se il progretto è ampio non ne parliamo...
perchè, la natura del C++ permette una migliore gestione dei progetti? 
C++ non ha *alcuna* gestione dei progetti
Pascal invece ha la parola-chiave uses, che permette di tracciare le 
dipendenze tra i vari moduli, e quindi di considerare i moduli di alto 
livello (program e library) dei veri e propri "progetti". Soprattutto 
occuparsi di includere una sola copia di ogni unit in ogni programma è 
lasciato, giustamente, al compilatore
qualcuno ha detto #include? ma per carità, almeno informatevi
C++ non ha il concetto di dipendenze (dimostrazione: non è il 
compilatore a dare i messaggi d'errore di dipendenze esterne non 
soddisfatte, è il linker, che è indipendente dal linguaggio), la parola 
chiave "extern" è un no-op ignorato dal compilatore, impossibile fare a 
meno delle import library, abuso del preprocessore (che avrebbero dovuto 
*abolire* per C++ perchè il linguaggio, con le costanti, le inline, i  
namespace e l'overloading degli operatori non ne ha più bisogno), e 
tante altre scomode eredità del C

diversi. 
ah no?
 - PHP crea automaticamente delle variabili globali con il nome dei 
   parametri passati allo script, e con il valore del parametro. 
   Conoscendo la struttura interna di uno script è possibile 
   sovrascriverne variabili globali passando le proprie come parametri
   (soluzione? disabilitare questa caratteristica)
 - C non ha alcun controllo a runtime sulla lunghezza delle stringhe 
   (nemmeno sa cosa siano le stringhe!). E incoraggia i programmatori ad 
   abusare dello stack. Con le conseguenze che conosciamo tutti. 
   Soluzione: usare lo heap anzichè lo stack, e imparare un po' di 
   structured exception handling, che non è appannaggio dell'OOP, a 
   differenza di diffuse credenze popolari. O cambiare linguaggio
 - la shell di Windows ha un pessimo escaping dei parametri (pare che 
   sia migliorato, ultimamente). Operatori del suo linguaggio verranno 
   considerati operatori anche quando dovrebbero essere considerati 
   parte dei parametri. Conseguenza: i parametri possono diventare 
   effettivamente del codice eseguibile => esecuzione di comandi 
   arbitrari. Soluzione: non esporre direttamente questo linguaggio
essere in rete significa semplicemente esporre a tutto il mondo (e nel 
mondo c'è un sacco di malintenzionati e teppisti) queste caratteristiche 
non sicure dei linguaggi

    abusare dello stack.
Io cmq parlavo di C++ che ha la sua bella classe string...
Per quanto riguarda il concetto di sicurezza del linguaggio e del programma
sono due cose diverse.
Es.
se il linguaggio è sicuro allora significa che ti costringe a programmare in
un certo modo, senza cercare di aggirare il problema i modi poco ortodossi.
se invece un programma è sicuro ciò può dipendere da varie altre cose, come
limitazioni imposte al linguaggio (come ad es. Java che non può scrivere su
file).
Ciao

> ma soprattutto,    che diavolo sono i template?
Ancora non li ho studiati ma cmq sono dei costrutti ( o astrazioni...) che
ti permettono di creare ad es. una classe che puň essere utilizzata con
qualsiasi tipo di dato.
/* Esempio anomalo */
int x;  // puoi assegnare solo valori int (negativi e positivi)
/* Non esiste in C++ ma credo possa rendere l'idea */
template x; // Assegni a x qualsiasi cosa, un int, una stringa etc...
Cmq se Cuni legge credo possa farti un esempio migliore.
ciao



Ti faccio un semplice esempio, implementa un C++ una classe vettore,
come fai?
Magari ne crei una per ogni tipo con cui la vuoi usare (magari con
copia incolla):
class VectorInt{...};
class VectorFloat{...};
o usi i template:
template<class T> class Vector{};
a questo punto se vuoi un vettore di int hai:
Vector<int> pippo;
se di float:
Vector<float> pippo;
ecc.
se vuoi puoi vederlo come un insieme di macro, in quanto semplificando
molto il compilatore crea una copia della classe template per ogni
tipo con cui č utilizzata.
A differenza delle pericolose macro i template sono perň gestiti dal
compilatore e per questo sono piů sicuri
Marco Barisione (ICQ 84277092)

[...]
Marco Barisione (ICQ 84277092)

 intendi?
prova ad assegnare un float a un int, e dimmi se l'errore te lo da
il compilarore o in esecuzione...

compilatore e per questo sono più sicuri
ok, allora in Delphi i template non ci sono, ma:
 - le classi capaci di tenere qualsiasi tipo di dato usano dei Pointer 
   generici (il typecast su un puntatore tipizzato è comunque 
   obbligatorio per poterlo dereferenziare. Generalmente, con un 
   generico Pointer in Delphi ci fai poco o niente). Vedere la unit
   Classes e gli oggetti TTree, TList e TQueue. Se proprio non vi piace, 
   derivate una classe e tipizzate quel puntatore
 - c'è un tipo di dati, il Variant, capace di tenere qualsiasi altro 
   tipo di dato, ma richiede OLE (non più)
 - i parametri di funzioni dichiarati come var e const possono essere
   senza tipo (necessario per compatibilità con il C)

 il compilarore o in esecuzione...
in C/C++ non mi da alcun errore, dato che esiste la conversione implicita 
da float a int. In Java non lo so, ma cmq non era questo quello che 
intendevo.
Io conosco Java solo superficialmente, però so che per usare la classe di 
libreria Vector è necessario fare una cosa del genere (lo scrivo in 
pseudo-codice perché non ricordo la sintassi precisa):
Mela mia_mela;
Banana mia_banana;
Vector contenitore_di_mele;
contenitore_di_mele.Inserisci_valore(mia_mela); // tutto ok
contenitore_di_mele.Inserisci_valore(mia_banana); // è sbagliato 
concettualmente ma compila tranquillamente.
(cast_verso_Mela)contenitore_di_mele[0]; // tutto ok
(cast_verso_Mela)contenitore_di_mele[1]; // errore runtime, in realtà è una 
banana
Se sbaglio qualcosa dimmelo, cmq a me non sembra che questo sia un grande 
esempio di type-safety a compile-time


 ah no?
hai ragione.


 Cmq se Cuni legge credo possa farti un esempio migliore.
template<class T> T max(T a, T b) 
{
  if (a>b) return a;
  return b;
}
Utilizzando i template non è necessario scriversi ogni volta una funzione 
max che utilizzi gli int, i float, i char, i double, le stringhe, i tipi 
definiti dall'utente ecc. Ci pensa automaticamente il compilatore. E' ovvio 
che dato che il compilatore conosce i tipi effettivi utilizzati dalla 
funzione (o da una classe) è in grado di eseguire a compile-time tutti i 
controlli di tipo necessari, al contrario di Java che spesso deve 
posticiparli a runtime.
Ciao Anto


 tante altre scomode eredità del C
questa tua frase meriterebbe di essere incorniciata: dimostra che IMHO hai 
capito molto poco del C++, cercando di trarre conclusioni senza neppure 
conoscerlo a fondo e fino in fondo (i.e. come fai a giudicare il C++ se non 
sai neppure cosa sono i template?).
Anto
PS: cmq sappi che io sono un grande estimatore del Pascal (come gli altri 
partecipanti del gruppo possono confermarti)...


Riscrivi le funzioni per ogni tipo?
Certo!
Fare quattro copia e incolla è più veloce che scriversi un
template; inoltre il listato diventa più ordinato e
leggibile, imho.
E poi, se serve, posso agevolmente aggirarne l'uso con i
tipi variant, al costo però di ottenere un eseguibile
leggermente più lento.
Inoltre la necessità di scrivere template è rarissima, un
programma che ne faccia un uso massiccio non riesco proprio
a immaginarlo, e se esiste, credo proprio che sia stato
progettato maluccio, in quanto lo scavalcamento del
controllo dei tipi può facilmente diventare un covo di bachi
:-)
-- 
So I dub thee Unforgiven.

:-)
La libreria standard del c++ ne fa ampissimo uso e non penso che sia
progettata maluccio. Perché scavalcamento del controllo dei tipi? cosa
intendi?
Comunque si pensa di aggiungere i template anche a Java, quindi non
sono proprio inutili (non sono sicuro di quello che sto dicendo ma
sono convinto di averlo sentito dire su qualche ng da qualcuno molto +
esperto di me)
Marco Barisione (ICQ 84277092)

hai ragione.
la ragione si da' ai fessi. Se hai qualcosa da dire, parla, se non hai 
niente da dire taci, piuttosto che abbaiare

altri partecipanti del gruppo possono confermarti)...
non importa. Mi interessa solo un esame sincero del C, che ha i suoi bei 
difetti. Il C++ ha solo delle cattive compagnie, sarebbe ora che 
l'ufficio reclami si mettesse in moto. I miei confronti con il Pascal, 
beh, è il mio "language of choice", lo conosco, lo uso, mi piace, e, 
dovendo programmare in C (non C++, dovrei studiarlo da zero e non ho 
tempo. C è abbastanza simile al subset procedurale del Pascal...) per 
progetti che non accettano altri linguaggi (vaglielo a dire che sono 
equivalenti :), so perfettamente perchè C *non* è il mio linguaggio 
preferito... e tu magari conoscerai Pascal e non ti sto dicendo nulla di 
nuovo, ma altri potrebbero essere convinti che a questo mondo esiste 
solo il C

 questo non rende assolutamente l'idea di cosa sia un template.
L'ho detto che era anomalo. Cmq io volevo mettere in evidenza soprattutto il
vantaggio che offrono per quanto riguarda l'utilizzo di tipi di dato
diverso.
con template x volevo dire che template era come se fosse il tipo che può
variare.

    derivate una classe e tipizzate quel puntatore
non sono affatto la stessa cosa. Il C++ tramite i template raggiunge una 
robusta type-safety a compile-time, mentre Delphi (e anche Java) devono 
posticiparla a runtime, con i prevedibili problemi che ci possono essere.
Anto


intendi?
Che con i template (e con i Variant) non si ha più il
controllo dei tipi.
Una template class può accettare _qualsiasi_ tipo, quindi
anche tipi non previsti, che potrebbero generare errori di
funzionamento o di risultato delle operazioni.


 funzionamento o di risultato delle operazioni.
Ti sbagli.  Realizzare il generic programming con i
template ha appunto questo vantaggio: che il controllo
dei tipi avviene appunto *a tempo di compilazione*
(l'istanziazione del template e` parte della fase di
compilazione del programma).  Questo ha modesti
vantaggi in termini di controllo degli errori (viene un
poco anticipato rispetto alla fase di testing, con una
piccola conseguente riduzione del costo di diagnosi),
e vantaggi molto sostanziali in termini di assoluta
ottimizzazione delle prestazioni.  E` proprio per questo
che la tua asserzione sull'equivalenza del Variant ai
template non puo` reggere.
Prendi ad esempio il 'max' che si accennava:
template<class T> inline
const T& max(const T&a, const T&b)
{
    return std::less<T>(a,b)?b:a;
}
Il compilatore, a fronte di una chiamata che gli
fa istanziare questo template, tipo
    x = max(y, z);
NON "accetta qualsiasi tipo" per x, y, e z: anzi!
y e z devono essere entrambe di tipo T, il tipo T
dev'essere tale da permettere il confronto
attraverso std::less<> (tipicamente accettando
un operator< per il controllo di weak-ordering),
_e_ x deve essere di un tipo cui puo` venire
assegnato un T.  Il compilatore e` tenuto a fare
tutti questi controlli all'istanziazione e segnalare
subito eventuali errori.  E se non vi sono errori,
l'ottimizzatore procede sulla base piu` favorevole
possibile.  Non vi e` modo di ottenere vantaggi
cosi` rilevanti tramite Variant...!
Alex (MVP Brainbench per il C++)

NON "accetta qualsiasi tipo" per x, y, e z: anzi!
Non puoi negare che questo codice è meno immediato (cioè
meno comprensibile a vista d'occhio: devi immaginare
mentalmente il funzionamento con i vari tipi possibili) e
non fa risparmiare tempo sulla scrittura e sviluppo del
programma (non dimenticare che è questo il topic del
thread). 


 niente da dire taci, piuttosto che abbaiare
 
da notare come ti sei implicitamente auto-definito fesso; e da notare anche 
che io non ho mai detto che tu lo sia.
Stiamo facendo una discussione: se io mi rendo conto di aver detto una 
cavolata e tu me lo fai notare è ovvio che io ti dia ragione, non credi?
Non vedo il motivo per difendere ad oltranza le proprie posizioni se si sa 
che sono sbagliate.
Certo che questa tua frase mi fa presagire che tu non mi darai mai, in 
nessun caso, ragione; e allora mi chiedo perché mai stiamo discutendo...


 difetti. 
va bene, chiudo qui la conversazione. Forse non ti sei accorto che io non 
ho mai parlato di C, ma *solo ed esclusivamente* di C++.
Per tua stessa ammissione non conosci quest'ultimo. Allora, per favore, 
evitiamo di parlarne.
Anto


 :-)
spero VIVAMENTE che questo sia un post ironico; cmq non è che si capisse 
tanto il tono ironico...


discutendo... 
no, semplicemente non ti dirò mai "hai ragione" e basta, senza 
"condimento" :) E se ti do' ragione subito, la discussione muore e a me 
rimangono delle lacune

 thread).
hai ragione. E' molto più veloce scrivere quattro righe di codice e fare 10 
copia e incolla che scriverne 5 una volta e basta.


Anto


So I dub thee Unforgiven.
Marco Barisione (ICQ 84277092)

 del C! non tu!
beh, allora ora è tutto chiaro.
Anche se non ho afferrato bene la natura del discorso. Ti riporto una 
parafrasi del dialogo:
"Il Java ti costringe a molti cast, quindi è poco type-safe. Il C++ è molto 
meglio da questo punto di vista" (Io)
"Però il C non è type-safe!" (Tu)
Uhm... non è che ci sia molta consequenzialità logica :-)


 perche ti sei fidato di una funzione generica?
mi sa che non sai di preciso come funzionano i template. Se un template non 
può essere istanziato perché i tipi degli argomenti sono incompatibili 
viene generato un errore di compilazione.
