Newsgroup: it.comp.programmare
Titolo: Perchè i compilatori sono tanto infid i?

Ciao,
ho appena trovato il motivo di un dannatissimo
errore in una funzione che ho scritto con gli stream.
Ci ho passato quasi tre ore a cercarlo. Quando
finalmente l'ho trovato e risolto, come al solito
l'errore segnalato dal compilatore era completamente
diverso dall'errore che invece avevo commesso.
E poi mi son reso conto che... E' SEMPRE COSI'...
o se non sempre, quasi. Tutte le volte che mi scordo
una parentesi, una virgola, un errore di battitura
la segnalazione che dà il compilatore è o ad una
riga sbagliata, o indica una causa diversa da quella
vera... non parliamo poi degli errori meno banali.
Ma, PERCHE' è così? Non è proprio possibile gestire
i messaggi di errore con un pò più di intelligenza?
Perchè nessun compilatore si preoccupa di fornire
dei messaggi di errore (almeno un pò più) precisi e
indicativi? Eppure non credo sia impossibile... e il
guadagno in produttività sarebbe enorme.

 indicativi? 
Fai un esempio? Il mio (g++), personalmente, mi soddisfa.
-- 
---
*************** | Have you ever retired a human by mystake?
*** Azathot *** |
*************** | To contact me, ask me gently. Thanks.

 No. 
Perchè no?

 guadagno in produttività sarebbe enorme.
No, leggi sopra. E' questione di esperienza. Poi, probabilmente si avrebbe
un certo guadagno di tempo nella scrittura di codice, ma quanto se ne
perderebbe per realizzare il compilatore?
Ciao
--
Noixe

errore in una funzione che ho scritto con gli stream.
[zip]
Penso che molto dipenda dal compilatore e dal linguaggio utilizzato.
Io utilizzo vari prodotti borland su sorgenti c e c++ e trovo che
errori sintattici quali punteggiature, parentesi, ecc. vengono sempre
segnalati con la massima precisione (al limite se dimentichi una
parentesi graffa ci vuole qualche secondo in + per capire come il
compilatore ha "accoppiato" quelle presenti). Il vero problema arriva
quando utilizzi i "maledetti" template (largamente utilizzati nella
libreria standard). Li trovare cosa veramente non va è spesso una
impresa ma penso che il compilatore centri poco... diciamo che è il
prezzo da pagare in cambio di + flessibilità & efficenza. Ad esempio
visto che i vector sono così comuni mi sono fatto una classina
personale (sicuramente meno efficente di quella standard) ma mooolto +
facile da debuggare!
Andrea
----
http://space.tin.it/io/andrea.fa

 Fai un esempio? Il mio (g++), personalmente, mi soddisfa.
Mi trovi d'accordo, Azathot; i compilatori non danno mica messaggi cosě
tanto sballati... tuttavia in parte č anche vero ciň che ha detto Noixe: a
volte i messaggi sono un po' strani perché il computer č sempre una
macchina! e neanche tanto intelligente per giunta: fa solo quello che gli
dici senza ragionare... :D
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it

 lusso di dimenticare un punto e virgola.
Non centra niente. L'architetto non ha il compilatore che lo avverte.
Piuttosto il programmatore non può concedersi il lusso di commettere errori
semantici, come ad es. implementare un algoritmo in maniera errata, pensando
che invece faccia ciò che pensa lui. Anche se gli errori semantici possono
derivare dagli errori sintattici, in generale questi ultimi sono segnalati
in maniera abbastanza efficiente dal compilatore e il programmatore può
trovare rapidamente un rimedio, chiaramente dipende dall'entità dell'errore.
Ciao
--
Noixe

 lusso di dimenticare un punto e virgola.
Fammi indovinare: tu sei un architetto e non un programmatore :-)

 Fai un esempio? Il mio (g++), personalmente, mi soddisfa.
anche a me; non c'e` nulla di piu` soddisfacente che provare a compilare
questo programma volutamente sbagliato:
#include <string>
int main()
{
        std::string s("anto", 4, 4, 4);
}
[anto@anto tmp]$ g++ prova.cc
prova.cc: In function `int main()':
prova.cc:5: no matching function for call to `std::basic_string<char,
std::char_traits<char>, std::allocator<char> >::basic_string(const char[5],
int, int, int)'
/usr/include/c++/3.2.2/bits/basic_string.tcc:233: candidates are:
std::basic_string<_CharT, _Traits, _Alloc>::basic_string(_Alloc::size_type,
_CharT, const _Alloc& = _Alloc()) [with _CharT = char, _Traits =
std::char_traits<char>, _Alloc = std::allocator<char>]
/usr/include/c++/3.2.2/bits/basic_string.tcc:226:                
std::basic_string<_CharT, _Traits, _Alloc>::basic_string(const _CharT*,
const _Alloc& = _Alloc()) [with _CharT = char, _Traits =
std::char_traits<char>, _Alloc = std::allocator<char>]
/usr/include/c++/3.2.2/bits/basic_string.tcc:220:                
std::basic_string<_CharT, _Traits, _Alloc>::basic_string(const _CharT*,
_Alloc::size_type, const _Alloc& = _Alloc()) [with _CharT = char, _Traits =
std::char_traits<char>, _Alloc = std::allocator<char>]
/usr/include/c++/3.2.2/bits/basic_string.tcc:213:                
std::basic_string<_CharT, _Traits, _Alloc>::basic_string(const
std::basic_string<_CharT, _Traits, _Alloc>&, _Alloc::size_type,
_Alloc::size_type, const _Alloc&) [with _CharT = char, _Traits =
std::char_traits<char>, _Alloc = std::allocator<char>]
/usr/include/c++/3.2.2/bits/basic_string.tcc:205:                
std::basic_string<_CharT, _Traits, _Alloc>::basic_string(const
std::basic_string<_CharT, _Traits, _Alloc>&, _Alloc::size_type,
_Alloc::size_type = std::basic_string<_CharT, _Traits, _Alloc>::npos) [with
_CharT = char, _Traits = std::char_traits<char>, _Alloc =
std::allocator<char>]
/usr/include/c++/3.2.2/bits/basic_string.tcc:192:                
std::basic_string<_CharT, _Traits, _Alloc>::basic_string(const
std::basic_string<_CharT, _Traits, _Alloc>&) [with _CharT = char, _Traits =
std::char_traits<char>, _Alloc = std::allocator<char>]
/usr/include/c++/3.2.2/bits/basic_string.tcc:199:                
std::basic_string<_CharT, _Traits, _Alloc>::basic_string(const _Alloc&)
[with _CharT = char, _Traits = std::char_traits<char>, _Alloc =
std::allocator<char>]
/usr/include/c++/3.2.2/bits/basic_string.h:926:                
std::basic_string<_CharT, _Traits, _Alloc>::basic_string() [with _CharT =
char, _Traits = std::char_traits<char>, _Alloc = std::allocator<char>]
ciao Anto
-- 
"Computer science is not about computers any more than astronomy
is about telescopes." -- EW Dijkstra

 ha scritto nel messaggio
news:2qZ7b.65352$R32.2...@news2.tin.it...


 c'era scritto flame, stupidi voi che rispondete
Si ma è anche possibile che qualcuno prenda seriamente quanto c'è scritto.
--
Noixe

 compilare questo programma volutamente sbagliato:
ROTFL
Il Borland si limita a dare l'errore, senza proporre le alternative.
Borland C++ 5.5.1 for Win32 Copyright (c) 1993, 2000 Borland
errstr.cpp:
Error E2285 errstr.cpp 5: Could not find a match for
'std::string::basic_string(char *,int,int,int)' in function main()
Warning W8004 errstr.cpp 6: 's' is assigned a value that is never used in
function main()
*** 1 errors in Compile ***
Molto meno soddisfacente, in effetti :-))
-- 
Gerolamo

 ha scritto nel messaggio > Si ma è anche possibile


 mi piace fare il troll ogni tanto dehihiho
Doh!
--
Noixe