Как лучше отключить предупреждение о неиспользуемых переменных?

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

Что было бы лучшим способом кодирования вокруг предупреждения?

#Ifdef вокруг функции?

#ifdef _MSC_VER
void ProcessOps::sendToExternalApp(QString sAppName, QString sImagePath, qreal qrLeft, qreal qrTop, qreal qrWidth, qreal qrHeight)
#else
void ProcessOps::sendToExternalApp(QString sAppName, QString sImagePath, qreal /*qrLeft*/, qreal /*qrTop*/, qreal /*qrWidth*/, qreal /*qrHeight*/)
#endif
{

Это так уродливо, но кажется, что компилятор предпочел бы.

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

Есть ли правильный путь?

Вы можете поместить это в " (void)var;" выражение (ничего не делает), чтобы компилятор увидел, что он используется. Это переносимо между компиляторами.

Например

void foo(int param1, int param2)
{
    (void)param2;
    bar(param1);
}

Или,

#define UNUSED(expr) do { (void)(expr); } while (0)
...

void foo(int param1, int param2)
{
    UNUSED(param2);
    bar(param1);
}

В GCC и Clang вы можете использовать __attribute__((unused))директиву препроцессора для достижения своей цели.
Например:

int foo (__attribute__((unused)) int bar) {
   return 0;
}

C ++ 17 теперь предоставляет [[maybe_unused]]атрибут.

http://en.cppreference.com/w/cpp/language/attributes

Довольно красиво и стандартно.

Ваше текущее решение лучше всего - закомментируйте имя параметра, если вы его не используете. Это относится ко всем компиляторам, поэтому вам не нужно использовать препроцессор, чтобы сделать это специально для GCC.

Обновление C ++ 17

В C ++ 17 мы получаем атрибут [[Maybe_unused]], который описан в [dcl.attr.unused]

Атрибут-маркер Maybe_unused указывает, что имя или сущность, возможно, намеренно не используются. Он должен появляться не более одного раза в каждом списке атрибутов, и ни один атрибут-аргумент-предложение не должен присутствовать. ...

Пример:

 [[maybe_unused]] void f([[maybe_unused]] bool thing1,
                        [[maybe_unused]] bool thing2) {
  [[maybe_unused]] bool b = thing1 && thing2;
    assert(b);
 }

Реализации не должны предупреждать, что b не используется, независимо от того, определен ли NDEBUG. - конец примера]

Для следующего примера:

int foo ( int bar) {
    bool unused_bool ;
    return 0;
}

И clang, и gcc генерируют диагностику, используя -Wall -Wextra для bar и unused_bool ( смотрите в прямом эфире ).

При добавлении [[Maybe_unused]] отключается диагностика:

int foo ([[maybe_unused]] int bar) {
    [[maybe_unused]] bool unused_bool ;
    return 0;
}

увидеть это в прямом эфире .

До C ++ 17

В C ++ 11 альтернативная форма UNUSEDмакроса может быть сформирована с использованием лямбда-выражения ( через Бен Дина ) с захватом неиспользуемой переменной:

#define UNUSED(x) [&x]{}()

Немедленный вызов лямбда-выражения должен быть оптимизирован, учитывая следующий пример:

int foo (int bar) {
    UNUSED(bar) ;
    return 0;
}

в Godbolt мы видим, что вызов оптимизирован:

foo(int):
xorl    %eax, %eax
ret

Еще более простой способ - просто закомментировать имена переменных:

int main(int /* argc */, char const** /* argv */) {
  return 0;
}

Коллега только что указал мне на этот хороший маленький макрос здесь

Для удобства я включу макрос ниже.

#ifdef UNUSED
#elif defined(__GNUC__) 
# define UNUSED(x) UNUSED_ ## x __attribute__((unused)) 
#elif defined(__LCLINT__) 
# define UNUSED(x) /*@unused@*/ x 
#else 
# define UNUSED(x) x 
#endif

void dcc_mon_siginfo_handler(int UNUSED(whatsig))

НКУне помечает эти предупреждения по умолчанию. Это предупреждение должно быть включено либо явным образом путем передачи -Wunused-parameterкомпилятору, либо неявным образом путем передачи -Wall -Wextra(или, возможно, какой-либо другой комбинации флагов).

Предупреждения о неиспользованных параметрах можно просто подавить, передав -Wno-unused-parameterих компилятору, но имейте в виду, что этот флаг отключения должен идти после любых возможных флагов включения этого предупреждения в командной строке компилятора, чтобы оно могло вступить в силу.

бесполезный и переносимый способ объявить один или несколько параметров неиспользуемыми:

template <typename... Args> inline void unused(Args&&...) {}

int main(int argc, char* argv[])
{
    unused(argc, argv);
    return 0;
}

Использование директив препроцессора в большинстве случаев считается злом. В идеале вы хотите избежать их, как вредителей. Помните, что заставить компилятор понять ваш код легко, а позволить другим программистам понять ваш код гораздо сложнее. Несколько десятков таких случаев здесь и там очень затрудняют чтение для вас самих или для других прямо сейчас.

Одним из способов может быть объединение ваших параметров в некоторый класс аргументов. Затем вы могли бы использовать только подмножество переменных (что на самом деле эквивалентно вашему назначению 0) или иметь разные специализации этого класса аргумента для каждой платформы. Однако это может не стоить того, вам нужно проанализировать, подходит ли оно.

Если вы можете прочитать невозможные шаблоны, вы можете найти дополнительные советы в книге «Исключительный C ++». Если бы люди, которые читали ваш код, могли использовать свои навыки для того, чтобы охватить сумасшедшие вещи, изложенные в этой книге, то у вас был бы прекрасный код, который также можно легко прочитать. Компилятор также будет хорошо осведомлен о том, что вы делаете (вместо того, чтобы скрывать все путем предварительной обработки)

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

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

Пример:

func(int a, int b)
{
    b;
    foo(a);
}

Это может показаться загадочным, поэтому определил макрос как UNUSED. MFC сделал это так:

#ifdef _DEBUG
#define UNUSED(x)
#else
#define UNUSED(x) x
#endif

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

Разве не безопасно всегда комментировать имена параметров? Если это не так, вы можете сделать что-то вроде

#ifdef _MSC_VER
# define P_(n) n
#else
# define P_(n)
#endif

void ProcessOps::sendToExternalApp(
    QString sAppName, QString sImagePath,
    qreal P_(qrLeft), qreal P_(qrTop), qreal P_(qrWidth), qreal P_(qrHeight))

Это немного менее уродливо.

Я видел это вместо (void)param2способа заставить замолчать предупреждение:

void foo(int param1, int param2)
{
    std::ignore = param2;
    bar(param1);
}

Похоже, это было добавлено в C ++ 11

Использование UNREFERENCED_PARAMETER(p)может работать. Я знаю, что он определен в WinNT.h для систем Windows и может быть легко определен и для gcc (если его еще нет).

UNREFERENCED PARAMETER(p) определяется как

#define UNREFERENCED_PARAMETER(P)          (P)

в WinNT.h.

Используйте флаг компилятора, например, флаг для GCC: -Wno-unused-variable

Вы можете использовать, __unusedчтобы сообщить компилятору, что переменная может не использоваться.

- (void)myMethod:(__unused NSObject *)theObject    
{
    // there will be no warning about `theObject`, because you wrote `__unused`

    __unused int theInt = 0;
    // there will be no warning, but you are still able to use `theInt` in the future
}

В C ++ 11 это решение, которое я использую:

template<typename... Ts> inline void Unreferenced(Ts&&...) {}

int Foo(int bar) 
{
    Unreferenced(bar);
    return 0;
}

int Foo2(int bar1, int bar2) 
{
    Unreferenced(bar1, bar2);
    return 0;
}

Проверено на переносимость (по крайней мере, на современных msvc, clang и gcc) и не создает дополнительного кода при включенной оптимизации. Без оптимизации выполняется дополнительный вызов функции, и ссылки на параметры копируются в стек, но макросы не используются.

Если дополнительный код является проблемой, вы можете использовать это объявление вместо:

(decltype(Unreferenced(bar1, bar2)))0;

но в этот момент макрос обеспечивает лучшую читаемость:

#define UNREFERENCED(...) { (decltype(Unreferenced(__VA_ARGS__)))0; }

Это хорошо работает, но требует C ++ 11

template <typename ...Args>
void unused(Args&& ...args)
{
  (void)(sizeof...(args));
}

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

Другой макрос должен был подавить предупреждение о неиспользуемой статической глобальной переменной.

template <typename T>
const T* UNUSED_VARIABLE(const T& dummy) { 
    return &dummy;
}
#define UNUSED_GLOBAL_VARIABLE(x) namespace {\
    const auto dummy = UNUSED_VARIABLE(x);\
}

static int a = 0;
UNUSED_GLOBAL_VARIABLE(a);

int main ()
{
    int b = 3;
    UNUSED_VARIABLE(b);
    return 0;
}

Это работает, потому что не будет предупреждений о нестатической глобальной переменной в анонимном пространстве имен.

C ++ 11 требуется, хотя

 g++  -Wall -O3  -std=c++11 test.cpp

Ржунимагу! Я не думаю, что есть еще один вопрос о СО, который раскрывает всех еретиков, испорченных Хаосом, лучше, чем этот!

При всем уважении к C ++ 17 в C ++ Core Guidelines есть четкое руководство . AFAIR, еще в 2009 году эта опция была доступна так же, как и сегодня. И если кто-то говорит, что это считается ошибкой в ​​Doxygen, то есть ошибка в Doxygen

Я не вижу твоей проблемы с предупреждением. Запишите это в заголовок метода / функции, чтобы компилятор xy выдал (правильное) предупреждение, но эти переменные необходимы для платформы z.

Предупреждение правильное, отключать его не нужно. Это не лишает законной силы программу - но это должно быть задокументировано, что есть причина.