Trong Visual C ++, có thể sử dụng #pragma warning (disable: ...). Ngoài ra tôi thấy rằng trong GCC bạn có thể ghi đè lên mỗi cờ trình biên dịch tệp . Làm cách nào tôi có thể làm điều này cho "dòng tiếp theo" hoặc với ngữ nghĩa đẩy / pop xung quanh các khu vực mã bằng GCC?

Có vẻ như điều này có thể được thực hiện . Tôi không thể xác định phiên bản GCC mà nó đã được thêm, nhưng đôi khi trước tháng 6 năm 2010.

Đây là một ví dụ:

#pragma GCC diagnostic error "-Wuninitialized"
    foo(a);         /* error is given for this one */
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wuninitialized"
    foo(b);         /* no diagnostic for this one */
#pragma GCC diagnostic pop
    foo(c);         /* error is given for this one */
#pragma GCC diagnostic pop
    foo(d);         /* depends on command line options */

Để loại bỏ tất cả mọi thứ, đây là một ví dụ về việc tạm thời vô hiệu hóa cảnh báo:

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-result"
    write(foo, bar, baz);
#pragma GCC diagnostic pop

Bạn có thể kiểm tra tài liệu GCC về các pragma chẩn đoán để biết thêm chi tiết.

TL; DR : Nếu nó hoạt động, hãy tránh hoặc sử dụng các chỉ định như __attribute__, nếu không_Pragma .

Đây là phiên bản ngắn của bài viết trên blog của tôi về Cảnh báo đàn áp trong GCC và Clang .

Hãy xem xét những điều sau đây Makefile

CPPFLAGS:=-std=c11 -W -Wall -pedantic -Werror

.PHONY: all
all: puts

để xây dựng puts.cmã nguồn sau

#include <stdio.h>

int main(int argc, const char *argv[])
{
    while (*++argv) puts(*argv);
    return 0;
}

Nó sẽ không biên dịch vì argckhông được sử dụng và các cài đặt là cứng (-W -Wall -pedantic -Werror ).

Có 5 điều bạn có thể làm:

• Cải thiện mã nguồn, nếu có thể
• Sử dụng một công cụ xác định khai báo, như __attribute__
• Sử dụng _Pragma
• Sử dụng #pragma
• Sử dụng một tùy chọn dòng lệnh.

Cải thiện nguồn

Nỗ lực đầu tiên nên kiểm tra xem mã nguồn có thể được cải thiện để thoát khỏi cảnh báo hay không. Trong trường hợp này, chúng tôi không muốn thay đổi thuật toán chỉ vì điều đó, như argclà dư thừa với !*argv( NULLsau phần tử cuối cùng).

Sử dụng một công cụ xác định khai báo, như __attribute__

#include <stdio.h>

int main(__attribute__((unused)) int argc, const char *argv[])
{
    while (*++argv) puts(*argv);
    return 0;
}

Nếu bạn may mắn, tiêu chuẩn sẽ cung cấp một công cụ xác định cho tình huống của bạn, như thế nào _Noreturn.

__attribute__là phần mở rộng GCC độc quyền (cũng được Clang hỗ trợ và một số trình biên dịch khác armcc) và sẽ không được nhiều trình biên dịch khác hiểu. Đặt __attribute__((unused))bên trong một macro nếu bạn muốn mã di động.

_Pragma nhà điều hành

_Pragmacó thể được sử dụng như là một thay thế cho #pragma.

#include <stdio.h>

_Pragma("GCC diagnostic push")
_Pragma("GCC diagnostic ignored \"-Wunused-parameter\"")

int main(int argc, const char *argv[])
{
    while (*++argv) puts(*argv);
    return 0;
}
_Pragma("GCC diagnostic pop")

Ưu điểm chính của _Pragmatoán tử là bạn có thể đặt nó bên trong các macro, điều này là không thể với lệnh #pragmanày.

Nhược điểm: Nó gần như là một nuke chiến thuật, vì nó hoạt động dựa trên dòng thay vì dựa trên khai báo.

Nhà _Pragmađiều hành đã được giới thiệu trong C99.

#pragma chỉ thị

Chúng tôi có thể thay đổi mã nguồn để chặn cảnh báo cho một vùng mã, điển hình là toàn bộ chức năng:

#include <stdio.h>

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-parameter"
int main(int argc, const char *argv[])
{
    while (*++argc) puts(*argv);
    return 0;
}
#pragma GCC diagnostic pop

Nhược điểm: Nó gần như là một nuke chiến thuật, vì nó hoạt động dựa trên dòng thay vì dựa trên khai báo.

Lưu ý rằng một cú pháp tương tự tồn tại trong tiếng kêu .

Loại bỏ cảnh báo trên dòng lệnh cho một tệp

Chúng tôi có thể thêm dòng sau vào Makefileđể loại bỏ cảnh báo cụ thể cho các lệnh:

CPPFLAGS:=-std=c11 -W -Wall -pedantic -Werror

.PHONY: all
all: puts

puts.o: CPPFLAGS+=-Wno-unused-parameter

Điều này có thể không muốn bạn muốn trong trường hợp cụ thể của bạn, nhưng nó có thể giúp những người đọc khác đang ở trong tình huống tương tự.

#define DIAG_STR(s) #s
#define DIAG_JOINSTR(x,y) DIAG_STR(x ## y)
#ifdef _MSC_VER
#define DIAG_DO_PRAGMA(x) __pragma (#x)
#define DIAG_PRAGMA(compiler,x) DIAG_DO_PRAGMA(warning(x))
#else
#define DIAG_DO_PRAGMA(x) _Pragma (#x)
#define DIAG_PRAGMA(compiler,x) DIAG_DO_PRAGMA(compiler diagnostic x)
#endif
#if defined(__clang__)
# define DISABLE_WARNING(gcc_unused,clang_option,msvc_unused) DIAG_PRAGMA(clang,push) DIAG_PRAGMA(clang,ignored DIAG_JOINSTR(-W,clang_option))
# define ENABLE_WARNING(gcc_unused,clang_option,msvc_unused) DIAG_PRAGMA(clang,pop)
#elif defined(_MSC_VER)
# define DISABLE_WARNING(gcc_unused,clang_unused,msvc_errorcode) DIAG_PRAGMA(msvc,push) DIAG_DO_PRAGMA(warning(disable:##msvc_errorcode))
# define ENABLE_WARNING(gcc_unused,clang_unused,msvc_errorcode) DIAG_PRAGMA(msvc,pop)
#elif defined(__GNUC__)
#if ((__GNUC__ * 100) + __GNUC_MINOR__) >= 406
# define DISABLE_WARNING(gcc_option,clang_unused,msvc_unused) DIAG_PRAGMA(GCC,push) DIAG_PRAGMA(GCC,ignored DIAG_JOINSTR(-W,gcc_option))
# define ENABLE_WARNING(gcc_option,clang_unused,msvc_unused) DIAG_PRAGMA(GCC,pop)
#else
# define DISABLE_WARNING(gcc_option,clang_unused,msvc_unused) DIAG_PRAGMA(GCC,ignored DIAG_JOINSTR(-W,gcc_option))
# define ENABLE_WARNING(gcc_option,clang_option,msvc_unused) DIAG_PRAGMA(GCC,warning DIAG_JOINSTR(-W,gcc_option))
#endif
#endif

Điều này sẽ làm thủ thuật cho gcc, clang và msvc

Có thể được gọi với ví dụ:

DISABLE_WARNING(unused-variable,unused-variable,42)
[.... some code with warnings in here ....]
ENABLE_WARNING(unused-variable,unused-variable,42)

xem https://gcc.gnu.org/onlinesocs/cpp/Pragmas.html , http://clang.llvm.org/docs/UsersManual.html#controlling-diagnostics-via-pragmas và https://msdn.microsoft .com / de-DE / library / d9x1s805.aspx để biết thêm chi tiết

Bạn cần ít nhất phiên bản 4.02 để sử dụng các loại pragma này cho gcc, không chắc chắn về msvc và clang về các phiên bản.

Có vẻ như việc xử lý pragma pop pop cho gcc bị hỏng một chút. Nếu bạn bật lại cảnh báo, bạn vẫn nhận được cảnh báo cho khối nằm trong khối DISABLE_WARNING / ENABLE_WARNING. Đối với một số phiên bản của gcc, nó hoạt động, đối với một số phiên bản thì không.

#pragma GCC diagnostic ignored "-Wformat"

Thay thế "-Wformat" bằng tên cờ cảnh báo của bạn.

AFAIK không có cách nào để sử dụng ngữ nghĩa đẩy / pop cho tùy chọn này.

Tôi gặp vấn đề tương tự với các thư viện bên ngoài như tiêu đề ROS. Tôi thích sử dụng các tùy chọn sau trong CMakeLists.txt để biên dịch chặt chẽ hơn:

set(CMAKE_CXX_FLAGS "-std=c++0x -Wall -Wextra -Wstrict-aliasing -pedantic -Werror -Wunreachable-code ${CMAKE_CXX_FLAGS}")

Tuy nhiên, làm điều này gây ra tất cả các loại lỗi phạm vi trong các thư viện bao gồm bên ngoài. Giải pháp là vô hiệu hóa tất cả các cảnh báo phạm vi trước khi bạn bao gồm các thư viện bên ngoài và bật lại như thế này:

//save compiler switches
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wpedantic"

//Bad headers with problem goes here
#include <ros/ros.h>
#include <sensor_msgs/LaserScan.h>

//restore compiler switches
#pragma GCC diagnostic pop

Tôi biết câu hỏi là về GCC, nhưng đối với những người đang tìm kiếm cách thực hiện điều này trong các trình biên dịch khác và / hoặc nhiều

TL; DR

Bạn có thể muốn xem Hedley , một tiêu đề C / C ++ đơn lẻ trong miền công cộng mà tôi đã viết rất nhiều thứ này cho bạn. Tôi sẽ đặt một phần nhanh về cách sử dụng Hedley cho tất cả điều này ở cuối bài này.

Vô hiệu hóa cảnh báo

#pragma warning (disable: …) có tương đương trong hầu hết các trình biên dịch:

• MSVC: #pragma warning(disable:4996)
• GCC: #pragma GCC diagnostic ignored "-W…"trong đó dấu chấm lửng là tên của cảnh báo;ví dụ như , #pragma GCC diagnostic ignored "-Wdeprecated-declarations.
• kêu vang : #pragma clang diagnostic ignored "-W…". Cú pháp về cơ bản giống như của GCC và nhiều tên cảnh báo giống nhau (mặc dù nhiều tên không).
• Trình biên dịch Intel C: Sử dụng cú pháp MSVC, nhưng hãy nhớ rằng các số cảnh báo là hoàn toàn khác nhau. Thí dụ:#pragma warning(disable:1478 1786) .
• PGI: Có một diag_suppress pragma:#pragma diag_suppress 1215,1444
• TI: Có một diag_suppress pragma có cùng cú pháp (nhưng các số cảnh báo khác nhau!) Như PGI:pragma diag_suppress 1291,1718
• Oracle Developer Studio (suncc): có một error_messages pragma. Khó chịu, các cảnh báo là khác nhau đối với trình biên dịch C và C ++. Cả hai đều vô hiệu hóa cùng một cảnh báo:
  • C: #pragma error_messages(off,E_DEPRECATED_ATT,E_DEPRECATED_ATT_MESS)
  • C ++: #pragma error_messages(off,symdeprecated,symdeprecated2)
• IAR: cũng sử dụng diag_suppressnhư PGI và TI, nhưng cú pháp thì khác. Một số số cảnh báo là như nhau, nhưng những số khác tôi đã chuyển hướng:#pragma diag_suppress=Pe1444,Pe1215
• Pelles C: tương tự như MSVC, mặc dù các số khác nhau #pragma warn(disable:2241)

Đối với hầu hết các trình biên dịch, thường nên kiểm tra phiên bản trình biên dịch trước khi thử tắt nó, nếu không, bạn sẽ chỉ kích hoạt một cảnh báo khác. Ví dụ: GCC 7 đã thêm hỗ trợ cho -Wimplicit-fallthroughcảnh báo, vì vậy nếu bạn quan tâm đến GCC trước 7, bạn nên làm gì đó như

#if defined(__GNUC__) && (__GNUC__ >= 7)
#  pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
#endif

Đối với clang và trình biên dịch dựa trên clang, chẳng hạn như các phiên bản XL C / C ++ và armclang mới hơn, bạn có thể kiểm tra xem trình biên dịch có biết về một cảnh báo cụ thể bằng cách sử dụng __has_warning()macro không.

#if __has_warning("-Wimplicit-fallthrough")
#  pragma clang diagnostic ignored "-Wimplicit-fallthrough"
#endif

Tất nhiên bạn cũng phải kiểm tra xem __has_warning()macro có tồn tại không:

#if defined(__has_warning)
#  if __has_warning("-Wimplicit-fallthrough")
#    pragma clang diagnostic ignored "-Wimplicit-fallthrough"
#  endif
#endif

Bạn có thể bị cám dỗ để làm một cái gì đó như

#if !defined(__has_warning)
#  define __has_warning(warning)
#endif

Vì vậy, bạn có thể sử dụng __has_warningmột chút dễ dàng hơn. Clang thậm chí còn gợi ý một cái gì đó tương tự cho __has_builtin()macro trong hướng dẫn của họ. Đừng làm điều này . Các mã khác có thể kiểm tra __has_warningvà quay lại kiểm tra các phiên bản trình biên dịch nếu nó không tồn tại và nếu bạn xác định __has_warningbạn sẽ phá vỡ mã của chúng. Cách đúng đắn để làm điều này là tạo một macro trong không gian tên của bạn. Ví dụ:

#if defined(__has_warning)
#  define MY_HAS_WARNING(warning) __has_warning(warning)
#else
#  define MY_HAS_WARNING(warning) (0)
#endif

Sau đó, bạn có thể làm những thứ như

#if MY_HAS_WARNING(warning)
#  pragma clang diagnostic ignored "-Wimplicit-fallthrough"
#elif defined(__GNUC__) && (__GNUC__ >= 7)
#  pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
#endif

Đẩy và bật

Nhiều trình biên dịch cũng hỗ trợ một cách để đẩy và bật các cảnh báo lên ngăn xếp. Ví dụ: điều này sẽ vô hiệu hóa cảnh báo trên GCC cho một dòng mã, sau đó đưa nó trở về trạng thái trước đó:

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated"
call_deprecated_function();
#pragma GCC diagnostic pop

Tất nhiên, không có nhiều thỏa thuận giữa các trình biên dịch về cú pháp:

• GCC 4.6+: #pragma GCC diagnostic push/#pragma GCC diagnostic pop
• tiếng kêu: #pragma clang diagnostic push/#pragma diagnostic pop
• Intel 13+ (và có thể sớm hơn): #pragma warning(push)/#pragma warning(pop)
• MSVC 15+ (VS 9.0 / 2008): #pragma warning(push)/#pragma warning(pop)
• ARM 5.6+: #pragma push/#pragma pop
• TI 8.1+: #pragma diag_push/#pragma diag_pop
• Pelles C 2.90+ (và có thể sớm hơn): #pragma warning(push)/#pragma warning(pop)

Nếu bộ nhớ phục vụ, đối với một số phiên bản GCC rất cũ (như 3.x, IIRC), các pragma đẩy / pop phải nằm ngoài chức năng.

Ẩn các thông tin chi tiết

Đối với hầu hết các trình biên dịch, có thể ẩn logic đằng sau các macro sử dụng _Pragma, được giới thiệu trong C99. Ngay cả trong chế độ không C99, hầu hết các trình biên dịch đều hỗ trợ _Pragma; ngoại lệ lớn là MSVC, có __pragmatừ khóa riêng với một cú pháp khác. Tiêu chuẩn _Pragmacó một chuỗi, phiên bản của Microsoft không:

#if defined(_MSC_VER)
#  define PRAGMA_FOO __pragma(foo)
#else
#  define PRAGMA_FOO _Pragma("foo")
#endif
PRAGMA_FOO

Gần tương đương, một khi được xử lý trước, để

#pragma foo

Điều này cho phép chúng tôi tạo các macro để chúng tôi có thể viết mã như

MY_DIAGNOSTIC_PUSH
MY_DIAGNOSTIC_DISABLE_DEPRECATED
call_deprecated_function();
MY_DIAGNOSTIC_POP

Và ẩn đi tất cả các kiểm tra phiên bản xấu xí trong các định nghĩa vĩ mô.

Cách dễ dàng: Hedley

Bây giờ bạn đã hiểu các cơ chế về cách làm những thứ như thế này một cách hợp lý trong khi giữ cho mã của bạn sạch sẽ, bạn hiểu một trong những dự án của tôi, Hedley làm gì. Thay vì đào qua hàng tấn tài liệu và / hoặc cài đặt nhiều phiên bản của nhiều trình biên dịch nhất có thể để kiểm tra, bạn chỉ có thể bao gồm Hedley (đây là một tiêu đề C / C ++ công khai duy nhất) và được thực hiện với nó. Ví dụ:

#include "hedley.h"

HEDLEY_DIAGNOSTIC_PUSH
HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
call_deprecated();
HEDLEY_DIAGNOSTIC_POP

Sẽ vô hiệu hóa cảnh báo về việc gọi một chức năng không dùng nữa trên GCC, clang, ICC, PGI, MSVC, TI, IAR, ODS, Pelles và có thể những người khác (tôi có lẽ sẽ không cập nhật câu trả lời này khi tôi cập nhật Hedley). Và, trên các trình biên dịch không được biết là hoạt động, các macro sẽ được xử lý trước thành không có gì, vì vậy mã của bạn sẽ tiếp tục hoạt động với bất kỳ trình biên dịch nào. Tất nhiên đó HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATEDkhông phải là cảnh báo duy nhất mà Hedley biết, cũng như vô hiệu hóa các cảnh báo mà tất cả Hedley có thể làm, nhưng hy vọng bạn hiểu ý.

Thay vì im lặng các cảnh báo, kiểu gcc thường sử dụng các cấu trúc C tiêu chuẩn hoặc __attribute__phần mở rộng để cho trình biên dịch biết thêm về ý định của bạn. Chẳng hạn, cảnh báo về phép gán được sử dụng như một điều kiện bị loại bỏ bằng cách đặt phép gán trong ngoặc đơn, tức là if ((p=malloc(cnt)))thay vì if (p=malloc(cnt)). Cảnh báo về các đối số chức năng không được sử dụng có thể bị loại bỏ bởi một số lẻ __attribute__tôi không bao giờ có thể nhớ hoặc tự gán, v.v. Nhưng nói chung tôi thích chỉ vô hiệu hóa toàn bộ bất kỳ tùy chọn cảnh báo nào tạo ra cảnh báo cho những điều sẽ xảy ra trong mã chính xác.

Đối với những người tìm thấy trang này đang tìm cách để làm điều này trong IAR, hãy thử điều này:

#pragma diag_suppress=Pe177
void foo1( void )
{
   /* The following line of code would normally provoke diagnostic 
      message #177-D: variable "x" was declared but never referenced.
      Instead, we have suppressed this warning throughout the entire 
      scope of foo1(). 
   */
   int x;
}
#pragma diag_default=Pe177

Xem http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.dui0472m/chr1359124244797.html để tham khảo.