Su parametri senza nome alle funzioni, C ++

Quello che segue è un codice C++ perfettamente legale

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

Mi chiedo, se esiste un valore per lasciare sempre parametri senza nome nelle funzioni, dato che non possono essere referenziati all’interno della funzione.

Perché è legale iniziare?

Sì, questo è legale. Questo è utile per implementazioni di virtual dalla class base in implementazioni che non intendono utilizzare il parametro corrispondente: devi dichiarare il parametro per far corrispondere la firma della funzione virtuale nella class base, ma non hai intenzione di usarlo, quindi non si specifica il nome.

L’altro caso comune è quando fornisci un callback ad alcune librerie, e devi conformarti ad una firma che la biblioteca ha stabilito (grazie, Aasmund Eldhuset per averlo portato a conoscenza ).

C’è anche un caso speciale per definire i tuoi operatori post-incremento e post-decremento : devono avere una firma con un parametro int , ma quel parametro è sempre inutilizzato. Questa convenzione è confinante con un hack nel design della lingua, però.

Naturalmente non nominare un parametro è legale quando si dichiara solo la funzione, ma è anche legale nell’implementazione. Quest’ultima versione apparentemente strana è utile quando la funzione deve dichiarare il parametro per avere una specifica firma fissa, ma il parametro non è necessario.

Ciò può accadere ad esempio per un metodo in una class derivata, per una funzione di callback o per un parametro template.

Non dando un nome al parametro si rende chiaro che il parametro non è necessario e il suo valore non verrà utilizzato. Alcuni compilatori se invece nominate un parametro e poi semplicemente non lo usano emetteranno un avvertimento che probabilmente c’è un problema con il corpo della funzione.

Voglio solo aggiungere che a volte c’è differenza se si nomina un parametro o no. Ad esempio, il compilatore tratta un riferimento rvalore denominato come un valore di lvalue e un riferimento rvalore senza nome come un valore rvalue.

 // named-reference.cpp // Compile with: /EHsc #include  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())); } 

Questo esempio produce il seguente risultato:

In g (const MemoryBlock &).
In g (MemoryBlock &&).

In questo esempio, la funzione principale passa un valore per f . Il corpo di f tratta il suo parametro chiamato come un lvalue. La chiamata da f a g lega il parametro a un riferimento lvalue (la prima versione di g sovraccaricata).