Clang vs GCC cho dự án Phát triển Linux của tôi

Tôi đang học đại học và trong một dự án chúng tôi đang sử dụng C. Chúng tôi đã khám phá GCC và Clang, và Clang dường như thân thiện với người dùng hơn nhiều so với GCC. Kết quả là, tôi tự hỏi những lợi thế hoặc bất lợi của việc sử dụng clang, trái ngược với GCC, để phát triển trong C và C ++ trên Linux là gì?

Trong trường hợp của tôi, nó sẽ được sử dụng cho các chương trình cấp độ sinh viên, không phải sản xuất.

Nếu tôi sử dụng Clang, tôi có nên gỡ lỗi với GDB và sử dụng GNU Make hay sử dụng trình gỡ lỗi khác và tạo tiện ích không?

BIÊN TẬP:

Các anh chàng gcc thực sự cải thiện trải nghiệm chẩn đoán trong gcc (cạnh tranh ah). Họ đã tạo một trang wiki để giới thiệu nó ở đây . gcc 4.8 bây giờ cũng có chẩn đoán khá tốt (gcc 4.9x thêm hỗ trợ màu). Clang vẫn đang dẫn đầu, nhưng khoảng cách đang đóng lại.

Nguyên:

Đối với sinh viên, tôi muốn giới thiệu Clang vô điều kiện.

Hiệu suất về mã được tạo giữa gcc và Clang hiện chưa rõ ràng (mặc dù tôi nghĩ rằng gcc 4.7 vẫn dẫn đầu, tôi chưa thấy điểm chuẩn kết luận nào), nhưng dù sao thì học sinh cũng không thực sự quan trọng.

Mặt khác, chẩn đoán cực kỳ rõ ràng của Clang chắc chắn dễ dàng hơn cho người mới bắt đầu để giải thích.

Hãy xem xét đoạn trích đơn giản này:

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

Bạn sẽ nhận thấy ngay rằng dấu chấm phẩy bị thiếu sau định nghĩa của Studentlớp, phải không :)?

Vâng, gcc cũng nhận thấy điều đó , sau một thời trang:

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

Và Clang cũng không chính xác đóng vai chính ở đây, nhưng vẫn:

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

Tôi cố tình chọn một ví dụ kích hoạt thông báo lỗi không rõ ràng (xuất phát từ sự mơ hồ trong ngữ pháp) chứ không phải là ví dụ điển hình "Ôi trời ơi Clang đọc suy nghĩ của tôi". Tuy nhiên, chúng tôi nhận thấy rằng Clang tránh được lũ lụt. Không cần phải sợ học sinh đi.

Tính đến thời điểm hiện tại, GCC có hỗ trợ tốt hơn và đầy đủ hơn cho các tính năng của C ++ 11 so với Clang. Ngoài ra, trình tạo mã cho GCC thực hiện tối ưu hóa tốt hơn so với Clang (theo kinh nghiệm của tôi, tôi chưa thấy bất kỳ thử nghiệm toàn diện nào).

Mặt khác, Clang thường biên dịch mã nhanh hơn GCC và tạo ra các thông báo lỗi tốt hơn khi có lỗi với mã của bạn.

Sự lựa chọn sử dụng cái nào thực sự phụ thuộc vào những thứ quan trọng đối với bạn. Tôi đánh giá cao sự hỗ trợ của C ++ 11 và chất lượng tạo mã hơn là tôi đánh giá sự tiện lợi của việc biên dịch. Vì điều này, tôi sử dụng GCC. Đối với bạn, sự đánh đổi có thể khác.

Tôi sử dụng cả hai vì đôi khi chúng đưa ra các thông báo lỗi khác nhau, hữu ích.

Dự án Python đã có thể tìm và sửa một số lỗi nhỏ khi một trong những nhà phát triển cốt lõi lần đầu tiên thử biên dịch với tiếng kêu.

Tôi sử dụng cả Clang và GCC, tôi thấy Clang có một số cảnh báo hữu ích, nhưng đối với các điểm chuẩn dò tia của riêng tôi - GCC chậm hơn 5-15% (dĩ nhiên là dùng hạt muối, nhưng đã cố gắng sử dụng các cờ tối ưu hóa tương tự cho cả hai).

Vì vậy, hiện tại tôi sử dụng phân tích tĩnh Clang và các cảnh báo của nó với các macro phức tạp: (mặc dù hiện tại các cảnh báo của GCC khá tốt - gcc4.8 - 4.9).

Một số cân nhắc:

• Clang không có hỗ trợ OpenMP, chỉ có vấn đề nếu bạn tận dụng điều đó nhưng vì tôi làm vậy, đó là một hạn chế đối với tôi. (*****)
• Biên dịch chéo có thể không được hỗ trợ tốt (ví dụ FreeBSD 10 vẫn sử dụng GCC4.x cho ARM), ví dụ gcc-mingw có sẵn trên Linux ... (YMMV).
• Một số IDE chưa hỗ trợ phân tích đầu ra Clangs ( ví dụ QtCreator *****). EDIT: QtCreator hiện hỗ trợ đầu ra của Clang
• Một số khía cạnh của GCC được ghi lại tốt hơn và vì GCC đã tồn tại lâu hơn và được sử dụng rộng rãi, bạn có thể thấy dễ dàng hơn khi nhận trợ giúp với các thông báo lỗi / thông báo lỗi.

***** - những lĩnh vực này đang được phát triển tích cực và có thể sớm được hỗ trợ

Đối với các chương trình cấp độ sinh viên, Clang có lợi ích là, theo mặc định, wrt chặt chẽ hơn. tiêu chuẩn C. Ví dụ: phiên bản K & R sau đây của Hello World được chấp nhận mà không có cảnh báo của GCC, nhưng bị Clang từ chối với một số thông báo lỗi mô tả khá hay:

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

Với GCC, bạn phải cung cấp cho nó -Werrorđể thực sự đưa ra quan điểm về việc đây không phải là một chương trình C89 hợp lệ. Ngoài ra, bạn vẫn cần sử dụng c99hoặc gcc -std=c99để có được ngôn ngữ C99.

Tôi nghĩ clang có thể là một sự thay thế.

GCC và clang có một số khác biệt về biểu thức như a+++++a, và tôi đã có nhiều câu trả lời khác nhau với bạn bè của tôi, những người sử dụng clang trên Mac trong khi tôi sử dụng gcc.

GCC đã trở thành tiêu chuẩn và tiếng kêu có thể là một sự thay thế. Bởi vì GCC rất ổn định và tiếng kêu vẫn đang được phát triển.