Wie unbenannte Funktionsargumente in C oder C++

Question

verwenden Wie verwende ich Funktion wie

erklärt Argumente

void f(double) 
{ 
    /**/ 
} 

wenn es möglich ist?

Answer 1

ich ein Beispiel hoffen, etwas Hilfe bieten kann:

// Declaration, saying there is a function f accepting a double. 
void f(double); 

// Declaration, saying there is a function g accepting a double. 
void g(double); 

// ... possibly other code making use of g() ... 

// Implementation using the parameter - this is the "normal" way to use it. In 
// the function the parameter is used and thus must be given a name to be able 
// to reference it. This is still the same function g(double) that was declared 
// above. The name of the variable is not part of the function signature. 
void g(double d) 
{ 
    // This call is possible, thanks to the declaration above, even though 
    // the function definition is further down. 
    f(d); 
} 

// Function having the f(double) signature, which does not make use of 
// its parameter. If the parameter had a name, it would give an 
// "unused variable" compiler warning. 
void f(double) 
{ 
    cout << "Not implemented yet.\n"; 
} 

Answer 2

Nein. Sie müssen ihm einen Namen geben. I.e.

void f(double myDouble) 
{ 
    printf("%f", myDouble * 2); 
} 

oder wenn Sie mit iostreams:

void f(double myDouble) 
{ 
    cout << myDouble * 2; 
} 

Answer 3

Der Parameter auf den Stapel kann noch gestellt bekommen, so können Sie in der Lage sein, es dort zu finden (siehe Kommentare unten)

Für Beispiel nur (hoch nicht tragbaren)

#include<stdio.h> 
void f(double) 
{ 
    double dummy; 
    printf("%lf\n",*(&dummy-2)); //offset of -2 works for *my* compiler 
} 

int main() 
{ 
    f(3.0); 
} 

Ich bin nicht sicher, warum diese

Answer 4

Compiler obwohl wollen würde tun, wird standardmäßig 0 passieren .... its die Art, wie wir früher postfix Inkrementoperator unterscheiden, und wir haben nie bestanden den tatsächlichen Wert verwenden ..

Answer 5

Hier ist eine gute link

void bar(int arg1, int /* Now unnamed */, int arg3) 
{ 
    // code for bar, using arg1 and arg3 
} 

Manchmal wird der obige Ansatz nicht nur verwendet, um Legacy-Code zu unterstützen, sondern auch, um sicherzustellen, dass eine überladene Funktion ausgewählt wird, vielleicht ein Konstruktor. Mit anderen Worten, Sie übergeben ein zusätzliches Argument, um sicherzustellen, dass eine bestimmte Funktion ausgewählt wird. Außerdem kann es während der Codeentwicklung hilfreich sein, ein unbenanntes Argument zu verwenden, wenn Sie beispielsweise Stubs für einige Routinen schreiben.

Wenn möglich, sollte wahrscheinlich argumentiert werden, dass unbenutzte Parameter sowohl von der Funktion als auch von allen Aufrufpunkten vollständig entfernt werden sollten, es sei denn, Sie versuchen speziell, den Operator neu zu überladen oder so etwas.