如何最好地使未使用变量的警告静音？

我有一个跨平台应用程序，在我的一些函数中，并没有使用传递给函数的所有值。因此，我从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);
 }

无论是否定义了NDEBUG，实现都不应警告b未使用。—完示例]

对于以下示例：

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

clang和gcc都使用-Wall -Wextra为bar和未使用_bool生成诊断（实时观看）。

添加[[maybe_unused]]会使诊断静音：

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

看到它直播。

在C ++ 17之前

在C ++ 11中，UNUSED可以使用lambda表达式（通过Ben Deane）并捕获未使用的变量来形成宏的另一种形式：

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

给定以下示例，应优化对lambda表达式的立即调用：

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），或者为每个平台使用该参数类的不同专业。但是，这可能不值得，您需要分析它是否适合。

如果您可以阅读不可能的模板，则可以在“ Exceptional 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)可以工作。我知道它是在Windows系统的WinNT.h中定义的，也可以很容易地为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

大声笑！我不认为在SO上还有另一个问题能比这个更好地揭示所有被混沌破坏的异端！

在充分尊重C ++ 17的前提下，《C ++核心准则》中有明确的准则。早在2009年，AFAIR就一直提供此选项。如果有人说这被认为是Doxygen中的错误，那么Doxygen中就有一个错误

我看不到您的警告问题。将其记录在方法/函数标头中，编译器xy会在此处发出（正确）警告，但是平台z需要这些变量。

该警告是正确的，无需将其关闭。它不会使程序无效-但应记录在案，这是有原因的。