Як найкраще заглушити попередження про невикористані змінні?

У мене є кросплатформна програма, і в деяких моїх функціях використовуються не всі значення, передані функціям. Тому я отримую попередження від 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;
}

Тепер [[maybe_unused]]атрибут надає C ++ 17 .

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

Обидва брязкоту і G генерують діагностики з допомогою -Wall -Wextra як для бару і unused_bool ( див наживо ).

Додаючи [[можливо_надійний]], приглушує діагностику:

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

побачити його наживо .

До С ++ 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))

gccне позначає ці попередження за замовчуванням. Це попередження повинно бути включено або явно, переходячи -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 ++". Якби люди, які читали ваш код, могли отримати свій набір навичок, щоб охопити шалені речі, викладені в цій книзі, то у вас буде прекрасний код, який також можна легко прочитати. Компілятор також добре знає, що ви робите (замість того, щоб приховувати все попередньою обробкою)

Спочатку попередження генерується визначенням змінної у вихідному файлі, а не у заголовку. Заголовок може залишатися незайманим і повинен, оскільки ви можете використовувати щось на зразок доксигену для створення 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 ++ . AFAIR, ще в 2009 році ця опція була доступна як і сьогодні. І якщо хтось каже, що це вважається помилкою в Doxygen, то в Doxygen є помилка

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

Попередження правильне, не потрібно вимикати його. Це не визнає програмою недійсною - але це має бути задокументовано, що є причина.