Clang vs GCC para o meu projeto de desenvolvimento Linux

Estou na faculdade e, para um projeto que estamos usando C. Exploramos o GCC e o Clang, e o Clang parece ser muito mais amigável que o GCC. Como resultado, estou me perguntando quais são as vantagens ou desvantagens de usar o clang, em oposição ao GCC, para desenvolver em C e C ++ no Linux?

No meu caso, isso seria usado para programas em nível de aluno, não para produção.

Se eu usar o Clang, devo depurar com o GDB e usar o GNU Make, ou usar outro depurador e criar utilitário?

EDITAR:

O pessoal do gcc realmente melhorou a experiência de diagnóstico no gcc (ah concorrência). Eles criaram uma página wiki para mostrá-la aqui . O gcc 4.8 agora também possui diagnósticos muito bons (suporte a cores adicionado ao gcc 4.9x). Clang ainda está na liderança, mas a diferença está diminuindo.

Original:

Para os alunos, eu recomendaria incondicionalmente o Clang.

O desempenho em termos de código gerado entre o gcc e o Clang agora não está claro (embora eu ache que o gcc 4.7 ainda lidera, ainda não vi benchmarks conclusivos), mas para os alunos aprenderem, isso realmente não importa.

Por outro lado, os diagnósticos extremamente claros de Clang são definitivamente mais fáceis para os iniciantes interpretarem.

Considere este trecho simples:

#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";
}

Você notará imediatamente que o ponto-e-vírgula está ausente após a definição do Student classe, certo :)?

Bem, o GCC também nota , de certa forma:

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 não está exatamente estrelando aqui também, mas ainda assim:

/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.

Eu escolhi propositadamente um exemplo que aciona uma mensagem de erro pouco clara (proveniente de uma ambiguidade na gramática), em vez dos exemplos típicos "Oh meu Deus, Clang, leia minha mente". Ainda assim, percebemos que o Clang evita o fluxo de erros. Não há necessidade de assustar os alunos.

No momento, o GCC tem um suporte muito melhor e mais completo para os recursos do C ++ 11 do que o Clang. Além disso, o gerador de código para o GCC executa uma otimização melhor do que o de Clang (na minha experiência, eu não vi nenhum teste exaustivo).

Por outro lado, o Clang geralmente compila o código mais rapidamente que o GCC e produz melhores mensagens de erro quando há algo errado com o seu código.

A escolha de qual usar realmente depende do que é importante para você. Eu valorizo ​​mais o suporte ao C ++ 11 e a qualidade de geração de código do que a conveniência da compilação. Por causa disso, eu uso o GCC. Para você, os trade-offs podem ser diferentes.

Eu uso os dois porque às vezes eles dão mensagens de erro diferentes e úteis.

O projeto Python conseguiu encontrar e corrigir vários pequenos bugs quando um dos principais desenvolvedores tentou compilar com o clang.

Eu uso o Clang e o GCC, acho que o Clang tem alguns avisos úteis, mas para meus próprios benchmarks de rastreamento de raios - é consistentemente 5-15% mais lento que o GCC (leve isso com grão de sal, é claro, mas tentei usar sinalizadores de otimização semelhantes) para ambos).

Então, por enquanto, uso a análise estática de Clang e seus avisos com macros complexas: (embora agora os avisos do GCC sejam igualmente bons - gcc4.8 - 4.9).

Algumas considerações:

• Clang não tem suporte ao OpenMP, só importa se você tirar proveito disso, mas desde que eu faço isso, é uma limitação para mim. (*****)
• A compilação cruzada pode não ser tão bem suportada (o FreeBSD 10, por exemplo, ainda usa o GCC4.x para ARM), o gcc-mingw, por exemplo, está disponível no Linux ... (YMMV).
• Alguns IDE ainda não suportam a análise da saída de Clangs ( Clangs QtCreator, por exemplo, *****). EDIT: QtCreator agora suporta a saída de Clang
• Alguns aspectos do GCC são mais bem documentados e, como o GCC existe há mais tempo e é amplamente usado, talvez seja mais fácil obter ajuda com avisos / mensagens de erro.

***** - essas áreas estão em desenvolvimento ativo e em breve poderão ser apoiadas

Para programas em nível de aluno, o Clang tem o benefício de, por padrão, ser mais rígido. o padrão C. Por exemplo, a seguinte versão K&R do Hello World é aceita sem aviso prévio pelo GCC, mas rejeitada pelo Clang com algumas mensagens de erro bastante descritivas:

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

Com o GCC, você deve dar o seu consentimento -Werrorpara que ele realmente faça questão de não ser um programa C89 válido. Além disso, você ainda precisa usar c99ou gcc -std=c99obter o idioma C99.

Eu acho que o clang poderia ser uma alternativa.

GCC e clang têm algumas diferenças em expressões como a+++++a , e eu tenho muitas respostas diferentes com meus colegas que usam clang no Mac enquanto eu uso o gcc.

O CCG se tornou o padrão e o clang pode ser uma alternativa. Porque o GCC é muito estável e o clang ainda está em desenvolvimento.