Невикористаний параметр в c ++ 11

У c ++ 03 і раніше для вимкнення попередження компілятора про невикористаний параметр я зазвичай використовую такий код:

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

Наприклад

int main(int argc, char *argv[])
{
    UNUSED(argc);
    UNUSED(argv);

    return 0;
}

Але макроси - це не найкраща практика для c ++, тому. Чи з'являється якесь краще рішення зі стандартом c ++ 11? Я маю на увазі, чи можу я позбутися макросів?

Дякую за все!

Для цього я використав функцію з порожнім тілом:

template <typename T>
void ignore(T &&)
{ }

void f(int a, int b)
{
  ignore(a);
  ignore(b);
  return;
}

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

Ви можете просто опустити імена параметрів:

int main(int, char *[])
{

    return 0;
}

А у випадку з main ви можете навіть взагалі пропустити параметри:

int main()
{
    // no return implies return 0;
}

Див. "§ 3.6 Початок та припинення дії" стандарту C ++ 11.

Є <tuple>в C ++ 11 , який включає готовий до використання std::ignoreоб’єкт, який дозволяє нам писати (дуже ймовірно, без накладення накладних витрат на виконання):

void f(int x)
{
    std::ignore = x;
}

Щоб "вимкнути" це попередження, найкраще уникати написання аргументу, просто напишіть тип.

void function( int, int )
{
}

або, якщо хочете, прокоментуйте:

void function( int /*a*/, int /*b*/ )
{
}

Ви можете змішувати іменовані та неназвані аргументи:

void function( int a, int /*b*/ )
{
}

У C ++ 17 у вас є специфікатор атрибута [[можливо_не використаний]], наприклад:

void function( [[maybe_unused]] int a, [[maybe_unused]] int b )
{
}

Нічого еквівалентного, ні.

Отже, ви застрягли в тих самих старих варіантах. Ви раді повністю пропустити імена у списку параметрів?

int main(int, char**)

У конкретному випадку main, звичайно, ви можете просто опустити самі параметри:

int main()

Існують також типові хитрощі для конкретного впровадження, такі як GCC __attribute__((unused)).

Макроси можуть бути не ідеальними, але вони роблять хорошу роботу саме для цієї мети. Я б сказав, дотримуйтесь макросу.

Що ви маєте проти старого та стандартного способу?

void f(int a, int b)
{
  (void)a;
  (void)b;
  return;
}

Нічого нового доступного немає.

Найкраще для мене підходить коментування імені параметра у реалізації. Таким чином, ви позбудетеся попередження, але все одно зберігаєте деяке уявлення про параметр (оскільки ім’я доступне).

Ваш макрос (і будь-який інший підхід "відміни до порожнечі") має мінус у тому, що ви можете фактично використовувати параметр після використання макросу. Це може ускладнити підтримку коду.

Заголовок Boost <boost/core/ignore_unused.hpp>(Boost> = 1,56) для цього визначає шаблон функції boost::ignore_unused().

int fun(int foo, int bar)
{
  boost::ignore_unused(bar);
#ifdef ENABLE_DEBUG_OUTPUT
  if (foo < bar)
    std::cerr << "warning! foo < bar";
#endif

  return foo + 2;
}

PS C ++ 17 має [[maybe_unused]]атрибут придушення попереджень щодо невикористаних сутностей.

Мені дуже подобається використовувати для цього макроси, оскільки це дозволяє вам краще контролювати, коли у вас є різні збірки налагодження (наприклад, якщо ви хочете будувати з включеними твердженнями):

#if defined(ENABLE_ASSERTS)
  #define MY_ASSERT(x) assert(x)
#else
  #define MY_ASSERT(x)
#end

#define MY_UNUSED(x)

#if defined(ENABLE_ASSERTS)
  #define MY_USED_FOR_ASSERTS(x) x
#else
  #define MY_USED_FOR_ASSERTS(x) MY_UNUSED(x)
#end

а потім використовувати його як:

int myFunc(int myInt, float MY_USED_FOR_ASSERTS(myFloat), char MY_UNUSED(myChar))
{
  MY_ASSERT(myChar < 12.0f);
  return myInt;
}

У мене є власна реалізація для критично важливих для часу сегментів коду. Я досліджував деякий час критичний для часу код для уповільнення і виявив, що ця реалізація споживає близько 2% від критичного часу, який я оптимізував:

#define UTILITY_UNUSED(exp) (void)(exp)
#define UTILITY_UNUSED2(e0, e1) UTILITY_UNUSED(e0); UTILITY_UNUSED(e1)
#define ASSERT_EQ(v1, v2) { UTILITY_UNUSED2(v1, v2); } (void)0

Критично важливий для часу код використовував ASSERT*означення для цілей налагодження, але у звіті він явно вирізаний, але ... Здається, цей виробляє трохи швидший код у Visual Studio 2015 Update 3:

#define UTILITY_UNUSED(exp) (void)(false ? (false ? ((void)(exp)) : (void)0) : (void)0)
#define UTILITY_UNUSED2(e0, e1) (void)(false ? (false ? ((void)(e0), (void)(e1)) : (void)0) : (void)0)

Причина в подвійному false ? вираженні. Це якимось чином виробляє трохи швидший код у випуску з максимальною оптимізацією.

Я не знаю, чому це швидше (здається, помилка в оптимізації компілятора), але це принаймні краще рішення для цього випадку коду.

Примітка : Найголовніше тут, що критично важливий для часу код сповільнюється без вищезазначених тверджень або невикористаних макросів у випуску. Іншими словами, подвійний false ?вираз напрочуд допомагає оптимізувати код.

windows.h визначає UNREFERENCED_PARAMETER :

#define UNREFERENCED_PARAMETER(P) {(P) = (P);}

Отже, ви можете зробити це так:

#include <windows.h>
#include <stdio.h>
int main(int argc, char **argv) {
  UNREFERENCED_PARAMETER(argc);
  puts(argv[1]);
  return 0;
}

Або за межами Windows:

#include <stdio.h>
#define UNREFERENCED_PARAMETER(P) {(P) = (P);}
int main(int argc, char **argv) {
  UNREFERENCED_PARAMETER(argc);
  puts(argv[1]);
  return 0;
}