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

Why does C++ allow unnamed function parameters?

本文关键字：函数 参数 未命名 许使用 C++ 为什么      更新时间：2023-10-16

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

void foo (int) {
    cout << "Yo!" << endl;
}
int main (int argc, char const *argv[]) {
    foo(5); 
    return 0;
}

我想知道，考虑到函数中不能引用未命名参数这一事实，是否有一个值可以在函数中保留未命名参数。

为什么一开始这是合法的？

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

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

定义自己的后增量和后减量运算符也有一种特殊情况：它们必须具有带有int参数的签名，但该参数始终未使用。不过，这种约定在语言设计上近乎于一种破解。

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

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

不给参数命名表明不需要该参数，也不会使用其值。有些编译器，如果你改为命名一个参数，然后干脆不使用它，就会发出一个警告，说函数体可能有问题。

我只想提到一个特定的（不同寻常但有趣的）用例——"passkey习语"。

它使用一个类型的"dummy"参数，其构造函数只能由其朋友访问它的目的只是检查调用方是否有权访问此构造函数。因此，它不需要名称，因为它没有在函数中使用，只有编译器使用它。

它是这样使用的：

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

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

// 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（内存块&&）中。

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

相关文章：