Linux Geliştirme projem için Clang vs GCC

Üniversitedeyim ve bir proje için C kullanıyoruz. GCC ve Clang'ı keşfettik ve Clang GCC'den çok daha kullanıcı dostu görünüyor. Sonuç olarak, Linux'ta C ve C ++ 'da geliştirmek için GCC'nin aksine clang kullanmanın avantajlarının veya dezavantajlarının ne olduğunu merak ediyorum?

Benim durumumda bu, üretim değil öğrenci düzeyindeki programlar için kullanılacaktı.

Clang kullanırsam GDB ile hata ayıklamalı ve GNU Make kullanmalı mıyım, yoksa başka bir hata ayıklayıcı ve yardımcı program mı kullanmalıyım?

DÜZENLE:

Gcc çocuklar gcc'deki tanı deneyimini gerçekten geliştirdi (rekabet). Burada sergilemek için bir wiki sayfası oluşturdular . gcc 4.8 artık oldukça iyi bir tanılamaya sahip (gcc 4.9x renk desteği eklendi). Clang hala önde gidiyor, ancak boşluk kapanıyor.

Orijinal:

Öğrenciler için koşulsuz olarak Clang'ı tavsiye ederim.

Gcc ve Clang arasında üretilen kod açısından performans şimdi belirsizdir (gcc 4.7'nin hala öncü olduğunu düşünüyorum, ancak henüz kesin kriterler görmedim), ancak öğrencilerin öğrenmesi için zaten önemli değil.

Öte yandan, Clang'ın son derece net teşhisi yeni başlayanlar için kesinlikle daha kolaydır.

Bu basit snippet'i düşünün:

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

StudentSınıfın tanımından sonra noktalı virgülün eksik olduğunu hemen fark edeceksiniz , değil mi?

Eh, gcc de bunu fark şöyle böyle,:

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>]

Clang da burada tam olarak oynamıyor, ama yine de:

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

Kasten tipik "Oh tanrım Clang aklımı oku" örneklerinden ziyade belirsiz bir hata mesajını (gramerdeki bir belirsizlikten geliyor) tetikleyen bir örnek seçiyorum. Yine de, Clang'ın hatalardan kaçındığını fark ediyoruz. Öğrencileri korkutmaya gerek yok.

Şu an itibariyle, GCC, Clang 11 özellikleri için Clang'dan çok daha iyi ve daha eksiksiz bir desteğe sahip. Ayrıca, GCC için kod üreteci Clang'dakinden daha iyi optimizasyon gerçekleştirir (benim deneyimime göre, kapsamlı testler görmedim).

Öte yandan, Clang genellikle kodu GCC'den daha hızlı derler ve kodunuzda bir sorun olduğunda daha iyi hata mesajları üretir.

Hangisini kullanacağınız seçimi sizin için önemli olan şeylere bağlıdır. C ++ 11 desteğine ve kod oluşturma kalitesine değer veri derlemeden daha fazla değer veriyorum. Bu nedenle GCC kullanıyorum. Sizin için ödünleşmeler farklı olabilir.

İkisini de kullanıyorum çünkü bazen farklı, faydalı hata mesajları veriyorlar.

Python projesi, çekirdek geliştiricilerden biri ilk kez clang ile derlemeyi denediğinde bir dizi küçük mermi bulabildi ve düzeltebildi.

Hem Clang hem de GCC kullanıyorum, Clang'ın bazı yararlı uyarıları olduğunu düşünüyorum, ancak kendi ışın izleme kriterlerim için - GCC'den sonra sürekli olarak% 5-15 daha yavaş (tabii ki tuz tanesi ile alın, ancak benzer optimizasyon bayraklarını kullanmaya çalıştı) her ikisi için).

Şimdilik Clang statik analizini ve uyarılarını karmaşık makrolarla kullanıyorum: (şimdi GCC'nin uyarıları neredeyse iyi - gcc4.8 - 4.9).

Bazı düşünceler:

• Clang'ın OpenMP desteği yoktur, sadece bundan faydalanırsanız önemlidir, ancak yaptığımdan beri benim için bir sınırlama. (*****)
• Çapraz derleme iyi desteklenmeyebilir (örneğin FreeBSD 10 hala ARM için GCC4.x kullanır), örneğin gcc-mingw Linux'ta kullanılabilir ... (YMMV).
• Bazı IDE'ler henüz Clangs çıktısının ayrıştırılmasını desteklemez ( örneğin, QtCreator *****). EDIT: QtCreator artık Clang çıktısını destekliyor
• GCC'nin bazı yönleri daha iyi belgelenmiştir ve GCC daha uzun süredir etrafta bulunduğundan ve yaygın olarak kullanıldığından, uyarı / hata mesajlarıyla ilgili yardım almayı daha kolay bulabilirsiniz.

***** - bu alanlar aktif olarak geliştirilmektedir ve yakında desteklenecektir

Öğrenci düzeyindeki programlar için, Clang, varsayılan olarak daha katı wrt olma avantajına sahiptir. C standardı. Örneğin, Hello World'ün aşağıdaki K&R sürümü GCC tarafından uyarı yapılmaksızın kabul edilir, ancak Clang tarafından bazı açıklayıcı hata mesajları ile reddedilir:

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

GCC ile, bunun -Werrorgeçerli bir C89 programı olmadığı konusunda gerçekten bir noktaya gelmesini sağlamak için vermelisiniz . Ayrıca, hala C99 dilini kullanmanız c99veya gcc -std=c99almanız gerekir .

Bence clang bir alternatif olabilir.

GCC ve clang gibi ifadelerde bazı farklılıklar a+++++avar ve gcc kullanırken Mac'te clang kullanan akranımla birçok farklı cevabım var.

GCC standart haline geldi ve clang bir alternatif olabilir. Çünkü GCC çok kararlı ve clang hala gelişmekte.