为什么 C++ 允许未命名的函数参数？

Question

以下是完全合法的C++代码

void foo (int) {
    cout << "Yo!" << endl;
}

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

我想知道，是否有一个值可以在函数中留下未命名的参数，因为它们不能在函数内被引用。

为什么这首先是合法的？

Answer 1

是的，这是合法的。 这对于在不打算使用相应参数的实现中从基类实现虚拟非常有用：您必须声明参数以匹配基类中虚拟函数的签名，但您不打算使用它，所以你不指定名称。

另一种常见情况是当您向某个库提供回调时，您必须符合库已建立的签名（感谢Aasmund Eldhuset提出这一点）。

还有一种特殊情况可以定义您自己的后递增和后递减运算符：它们必须具有带有int参数的签名，但该参数始终未使用。 不过，这种约定接近于语言设计中的一种黑客行为。

Answer 2

当然，在声明函数时不命名参数是合法的，但在实现中也是合法的。 当函数需要声明参数具有特定的固定签名但不需要参数时，最后一个明显奇怪的版本很有用。

例如，对于派生类中的方法、回调函数或模板参数，可能会发生这种情况。

不给参数一个名称表明不需要参数并且不会使用它的值。 某些编译器如果您改为命名参数，然后根本不使用它，则会发出警告，表明函数体可能存在问题。

Answer 3

只是想提一个特定的（不寻常但有趣的）用例 - “密码成语”。

它使用一个类型的“虚拟”参数，它的构造函数只能被它的朋友访问。 它的目的只是检查调用者是否有权访问此构造函数。 所以它不需要名字，因为它没有在函数中使用，只有编译器使用它。

它是这样使用的：

class Friendly; // Just a forward declaration

class Key {
private:
    Key() {}
    friend class Friendly;
};

class Safe() {
public:
    static int locked(Key, int i) {
        // Do something with `i`,
        // but the key is never used.
        return i;
    }
private:
    static void inaccessible() {}
};

class Friendly {
public:
    void foo() {
        int i = Safe::locked(Key(), 1); // OK
        int j = Safe::locked({}, 2);    // OK, sice C++11
    }
    void bar() {
        Safe::inaccessible(); // Not OK, its inaccessible
    }
};

int i = Safe::locked(3);        // Not OK, wrong parameters
int j = Safe::locked(Key(), 4); // Not OK, `Key` constructor is inaccessible
int k = Safe::locked({}, 5);    // Not OK, `{}` means `Key()` implicitly

Answer 4

我只想补充一点，有时是否命名参数是有区别的。 例如，编译器将命名的右值引用视为左值，将未命名的右值引用视为右值。

// named-reference.cpp  
// Compile with: /EHsc  
#include <iostream>  
using namespace std;

// A class that contains a memory resource.  
class MemoryBlock  
{  
   // TODO: Add resources for the class here.  
};

void g(const MemoryBlock&)   
{  
   cout << "In g(const MemoryBlock&)." << endl;  
}

void g(MemoryBlock&&)   
{  
   cout << "In g(MemoryBlock&&)." << endl;  
}

MemoryBlock&& f(MemoryBlock&& block)  
{  
   g(block);  
   return block;  
}  

int main()  
{  
   g(f(MemoryBlock()));  
}  

此示例产生以下输出：

在 g(const MemoryBlock&) 中。
在 g(MemoryBlock&&) 中。

在这个例子中， main 函数将一个右值传递给f 。 f的主体将其命名参数视为左值。 从f到g的调用将参数绑定到左值引用（ g的第一个重载版本）。