Запретить предупреждение компилятора. Функция объявлена без ссылки.

Итак, у меня есть такой код:

void foo (int, int);

void bar ( )
{
    //Do Stuff

   #if (IMPORTANT == 1)
       foo (1, 2);
   #endif

}

При выполнении компиляции без "ВАЖНО" я получаю компилятор. Предупреждение о том, что foo определен и никогда не ссылается. Что заставило меня задуматься (вот в чем проблема).

Итак, чтобы исправить это, я просто добавил те же #if (IMPORTANT == 1) вокруг определения функции и т.д...., чтобы удалить предупреждение, а затем я начал задаваться вопросом, существует ли другой способ подавить это предупреждение для этой функции. Я смотрел на "неиспользованный" атрибут GCC и не знал, имеет ли функции тот же атрибут, который я мог бы установить? Есть ли еще один способ подавить его, который подавляет это предупреждение только для этой функции, а не для файла?

Ответы

Ответ 1

... потом я начал задаваться вопросом, есть ли другой способ подавить это предупреждение для этой функции.

Там могут быть опции компилятора, чтобы подавить это предупреждение. Однако одна хитрость заключается в следующем:

(void)foo; //cast it to void.

Это должно подавить это предупреждение.

Вы можете написать макрос:

#define SUPPRESS_WARNING(a) (void)a

void foo(int thisIsAlsoAnUnsedParameter, int usedParameter)
{
   SUPPRESS_WARNING(foo); //better do this inside the definition itself :D

   SUPPRESS_WARNING(thisIsAlsoAnUnsedParameter);
}

Как видите, само определение foo подавляет предупреждение.

Ответ 2

Я уверен, что соответствующая опция предупреждения такова:

-Wunused-function
Предупреждать о том, что статическая функция объявлена, но не определена или неиспользуемая статическая функция не используется. Это предупреждение включено -Wall.

Поэтому предупреждение следует указывать только для функции static, интересной. Имеет смысл. Если функция static, ее можно использовать только в текущем файле, поэтому ее определение также должно быть в этом файле.

И объявив, что static inline избегает предупреждения, не прибегая к уродливым макросам или прагмам или атрибутам, специфичным для компилятора.

Ответ 3

Одно из решений - через атрибуты функции.

void foo (int, int) __attribute__ ((unused));

Это скажет gcc не выпустить предупреждение о неиспользуемой функции для функции foo. Если вы беспокоитесь о переносимости, вы можете определить макрос UNUSED_FUNCTION_ATTRIBUTE, который расширяется до __attribute__ ((unused)) с компиляторами, которые поддерживают атрибуты, но в противном случае ничего не расширяется.

Ответ 4

В С++ 17 вы можете объявить свою функцию с помощью [[maybe_unused]]:

[[maybe_unused]] void foo (int, int);

Это будет подавлять предупреждение и является правильным, идиоматическим способом выражения возможной неиспользуемой функции в С++ 17.

Ответ 5

Хороший способ инкапсулировать компилятор и зависящий от системы материал - это включить его в заголовки. Затем вы настраиваете путь включения в зависимости от компилятора и системы и, возможно, других вещей. Вы можете сделать то же самое для файлов исходного кода.

В этом случае декларация, похоже, не зависит от компилятора или системы, поэтому просто добавьте следующий общий заголовок:

// [foo.h]
#pragma once
void foo( int, int );

С файлом реализации

// [foo.cpp]
#include <foo.virtual.cpp>

Затем для сборки, где что-то должно произойти, добавьте в путь include каталог, содержащий

// [foo.virtual.cpp]
#include <foo.h>
void foo( int const a, int const b )
{
    // Do the thing.
}

И для сборки, где ничего не должно произойти, добавьте в путь include каталог, содержащий

// [foo.virtual.cpp]
#include <foo.h>
void foo( int, int ) {}

Если вы боитесь, что вызов пустой функции будет очень трудоемким, например, нано-секунда впустую, просто переместите определения в заголовки и добавьте слово inline.

Если foo также используется для других целей, определите функцию bar, которая вызывает ее для дела "should-or-should-not-happen", и сделайте выше для bar вместо foo.

Затем вы удалили все материалы препроцессора.

Помните, что директивы препроцессора в коде некачественны.

Ответ 6

Я нахожу способ сделать это глобально, и он работает также в c

#define SUPPRESS_UNUSED_WARN(var) \
    int _dummy_tmp_##var = ((int)(var) & 0)

то вы используете его как:

static int foo(int a, int b)
{
    // ....
}
SUPRESS_UNUSED_WARN(foo);

его можно использовать для функций и глобальных переменных
он должен быть размещен глобально, чтобы работать.
он не может использоваться для локальных переменных

Ответ 7

Для целевой платформы ARM при использовании компилятора ARM используйте следующую директиву компилятора вокруг целевой функции, чтобы подавить это предупреждающее сообщение:

#pragma diag_suppress 177
void foo(void)
{
/* does something but is not being called for the current build */
}

Ответ 8

#define SUPPRESS_UNUSED_WARN(var) \
    int _dummy_tmp_##var = ((int)(var) & 0)

не работает в IAR, изменить на это будет работать:

#define SUPPRESS_UNUSED_WARN(var) \
     void _dummy_tmp_##var(void) { (void)(var); }

Ответ 9

Вы также можете определить макрос _CRT_SECURE_NO_DEPRECATE в настройках проекта Visual Studio.

Перейти к свойствам проекта → Свойства конфигурации → C/С++ → Препроцессор → Определения препроцессора

Добавить _CRT_SECURE_NO_DEPRECATE.

Вот оно.!

Запретить предупреждение компилятора. Функция объявлена ​​без ссылки.