Clang vs GCC per il mio progetto di sviluppo Linux

Sono al college e per un progetto che stiamo usando C. Abbiamo esplorato GCC e Clang e Clang sembra essere molto più user friendly di GCC. Di conseguenza, mi chiedo quali siano i vantaggi o gli svantaggi dell'utilizzo di clang, al contrario di GCC, per lo sviluppo in C e C ++ su Linux?

Nel mio caso questo sarebbe usato per programmi a livello di studente, non per produzione.

Se uso Clang, dovrei eseguire il debug con GDB e utilizzare GNU Make oppure utilizzare un altro debugger e creare utility?

MODIFICARE:

I ragazzi di gcc hanno davvero migliorato l'esperienza di diagnosi in gcc (ah competizione). Hanno creato una pagina wiki per mostrarla qui . gcc 4.8 ora ha anche una buona diagnostica (gcc 4.9x ha aggiunto il supporto colore). Clang è ancora in testa, ma il gap si sta chiudendo.

Originale:

Per gli studenti, consiglierei incondizionatamente Clang.

Le prestazioni in termini di codice generato tra gcc e Clang non sono ora chiare (anche se penso che gcc 4.7 abbia ancora il vantaggio, non ho ancora visto parametri di riferimento conclusivi), ma per gli studenti apprendere che non ha comunque importanza.

D'altra parte, la diagnostica estremamente chiara di Clang è sicuramente più facile da interpretare per i principianti.

Considera questo semplice frammento:

#include <string>
#include <iostream>

struct Student {
std::string surname;
std::string givenname;
}

std::ostream& operator<<(std::ostream& out, Student const& s) {
  return out << "{" << s.surname << ", " << s.givenname << "}";
}

int main() {
  Student me = { "Doe", "John" };
  std::cout << me << "\n";
}

Noterai subito che manca il punto e virgola dopo la definizione della Studentclasse, giusto :)?

Bene, anche gcc se ne accorge , dopo una moda:

prog.cpp:9: error: expected initializer before ‘&’ token
prog.cpp: In function ‘int main()’:
prog.cpp:15: error: no match for ‘operator<<’ in ‘std::cout << me’
/usr/lib/gcc/i686-pc-linux-gnu/4.3.4/include/g++-v4/ostream:112: note: candidates are: std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(std::basic_ostream<_CharT, _Traits>& (*)(std::basic_ostream<_CharT, _Traits>&)) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/lib/gcc/i686-pc-linux-gnu/4.3.4/include/g++-v4/ostream:121: note:                 std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(std::basic_ios<_CharT, _Traits>& (*)(std::basic_ios<_CharT, _Traits>&)) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/lib/gcc/i686-pc-linux-gnu/4.3.4/include/g++-v4/ostream:131: note:                 std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(std::ios_base& (*)(std::ios_base&)) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/lib/gcc/i686-pc-linux-gnu/4.3.4/include/g++-v4/ostream:169: note:                 std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(long int) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/lib/gcc/i686-pc-linux-gnu/4.3.4/include/g++-v4/ostream:173: note:                 std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(long unsigned int) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/lib/gcc/i686-pc-linux-gnu/4.3.4/include/g++-v4/ostream:177: note:                 std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(bool) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/lib/gcc/i686-pc-linux-gnu/4.3.4/include/g++-v4/bits/ostream.tcc:97: note:                 std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(short int) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/lib/gcc/i686-pc-linux-gnu/4.3.4/include/g++-v4/ostream:184: note:                 std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(short unsigned int) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/lib/gcc/i686-pc-linux-gnu/4.3.4/include/g++-v4/bits/ostream.tcc:111: note:                 std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(int) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/lib/gcc/i686-pc-linux-gnu/4.3.4/include/g++-v4/ostream:195: note:                 std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(unsigned int) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/lib/gcc/i686-pc-linux-gnu/4.3.4/include/g++-v4/ostream:204: note:                 std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(long long int) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/lib/gcc/i686-pc-linux-gnu/4.3.4/include/g++-v4/ostream:208: note:                 std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(long long unsigned int) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/lib/gcc/i686-pc-linux-gnu/4.3.4/include/g++-v4/ostream:213: note:                 std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(double) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/lib/gcc/i686-pc-linux-gnu/4.3.4/include/g++-v4/ostream:217: note:                 std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(float) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/lib/gcc/i686-pc-linux-gnu/4.3.4/include/g++-v4/ostream:225: note:                 std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(long double) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/lib/gcc/i686-pc-linux-gnu/4.3.4/include/g++-v4/ostream:229: note:                 std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(const void*) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/lib/gcc/i686-pc-linux-gnu/4.3.4/include/g++-v4/bits/ostream.tcc:125: note:                 std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(std::basic_streambuf<_CharT, _Traits>*) [with _CharT = char, _Traits = std::char_traits<char>]

E Clang non è nemmeno esattamente protagonista qui, ma comunque:

/tmp/webcompile/_25327_1.cc:9:6: error: redefinition of 'ostream' as different kind of symbol
std::ostream& operator<<(std::ostream& out, Student const& s) {
     ^
In file included from /tmp/webcompile/_25327_1.cc:1:
In file included from /usr/include/c++/4.3/string:49:
In file included from /usr/include/c++/4.3/bits/localefwd.h:47:
/usr/include/c++/4.3/iosfwd:134:33: note: previous definition is here
  typedef basic_ostream<char>           ostream;        ///< @isiosfwd
                                        ^
/tmp/webcompile/_25327_1.cc:9:13: error: expected ';' after top level declarator
std::ostream& operator<<(std::ostream& out, Student const& s) {
            ^
            ;
2 errors generated.

Ho scelto di proposito un esempio che innesca un messaggio di errore poco chiaro (proveniente da un'ambiguità nella grammatica) piuttosto che i tipici esempi "Oh mio dio Clang leggimi nella mente". Tuttavia, notiamo che Clang evita il diluvio di errori. Non c'è bisogno di spaventare gli studenti.

A partire da ora, GCC ha un supporto molto migliore e più completo per le funzionalità di C ++ 11 rispetto a Clang. Inoltre, il generatore di codice per GCC esegue un'ottimizzazione migliore rispetto a quello di Clang (nella mia esperienza, non ho visto alcun test esaustivo).

D'altra parte, Clang spesso compila il codice più rapidamente di GCC e produce messaggi di errore migliori quando c'è qualcosa di sbagliato nel tuo codice.

La scelta di quale usare dipende davvero da quali cose sono importanti per te. Apprezzo il supporto C ++ 11 e la qualità della generazione del codice più di quanto apprezzo la convenienza della compilazione. Per questo motivo, utilizzo GCC. Per te, i compromessi potrebbero essere diversi.

Uso entrambi perché a volte forniscono messaggi di errore diversi e utili.

Il progetto Python è stato in grado di trovare e correggere numerosi piccoli buglet quando uno degli sviluppatori principali ha provato a compilare con clang.

Uso sia Clang che GCC, trovo che Clang abbia alcuni avvertimenti utili, ma per i miei benchmark di ray-tracing - è costantemente più lento del 5-15% rispetto a GCC (prendilo ovviamente con granello di sale , ma ho provato a usare flag di ottimizzazione simili per entrambi).

Quindi per ora uso l'analisi statica di Clang e i suoi avvisi con macro complesse: (anche se ora gli avvisi di GCC sono abbastanza buoni - gcc4.8 - 4.9).

Alcune considerazioni:

• Clang non ha supporto OpenMP, conta solo se ne approfitti, ma da quando lo faccio, è una limitazione per me. (*****)
• La compilazione incrociata potrebbe non essere altrettanto supportata (FreeBSD 10 ad esempio usa ancora GCC4.x per ARM), ad esempio gcc-mingw è disponibile su Linux ... (YMMV).
• Alcuni IDE non supportano ancora l'analisi dell'output di Clangs ( ad esempio QtCreator *****). EDIT: QtCreator ora supporta l'output di Clang
• Alcuni aspetti di GCC sono meglio documentati e poiché GCC è in circolazione da più tempo ed è ampiamente utilizzato, potresti trovare più facile ottenere aiuto con avvisi / messaggi di errore.

*****: queste aree sono in fase di sviluppo attivo e potrebbero presto essere supportate

Per i programmi a livello di studente, Clang ha il vantaggio di essere, per impostazione predefinita, più rigorosa. lo standard C. Ad esempio, la seguente versione K&R di Hello World è accettata senza preavviso da GCC, ma rifiutata da Clang con alcuni messaggi di errore piuttosto descrittivi:

main()
{
    puts("Hello, world!");
}

Con GCC, devi darlo -Werrorper farlo davvero capire che questo non è un programma C89 valido. Inoltre, è ancora necessario utilizzare c99o gcc -std=c99per ottenere il linguaggio C99.

Penso che il clang potrebbe essere un'alternativa.

GCC e clang hanno alcune differenze su espressioni come a+++++a, e ho molte risposte diverse con il mio peer che usa clang su Mac mentre uso gcc.

GCC è diventato lo standard e il clang potrebbe essere un'alternativa. Perché GCC è molto stabile e il clang è ancora in fase di sviluppo.