Warum 'constexpr' Parameter nicht erlaubt sind?

Question

Es wäre nützlich, "conexpr" -Parameter zu haben, um Compiler-bekannte Werte zu unterscheiden und so in der Kompilierzeit Fehler erkennen zu können. Beispiele:

int do_something(constexpr int x) 
{ 
    static_assert(x > 0, "x must be > 0"); 
    return x + 5; 
} 

int do_something(int x) 
{ 
    if(x > 0) { cout << "x must be > 0" << endl; exit(-1); } 
    return x + 5; 
} 

int var; 

do_something(9); //instance 'do_something(constexpr int x)' and check arg validity at compile-time 

do_something(0); //produces compiler-error 

do_something(var); //instance 'do_something(int x)' 

Was ist ein ungültiger Code für jetzt. Kann mir jemand erklären, warum das nicht umgesetzt werden kann?

EDIT:

Vorlagen Benutzer verwenden sollte sicherstellen, dass Literale wird immer als Vorlage Argument und nicht als Funktion diejenigen geführt, die sehr unbequem:

template<int x> 
int do_something() 
{ 
    static_assert(x > 0, "x must be > 0"); 
    return x + 5; 
} 

int do_something(int x) 
{ 
    if(x > 0) { cout << "x must be > 0" << endl; exit(-1); } 
    return x + 5; 
} 

int var; 

do_something(9); //instance 'do_something(int x)' and doesn't checks validity at compile-time 

do_something(0); //same as above, if check was performed - compiler error should occur 

do_something<9>(); //instance template 'do_something<int>()' 

do_something<0>(); //produces compiler error 

do_something(var); //instance 'do_something(int x)' 

Answer 1

Während dies in der Theorie gut klingt, ist es nicht nützlich in der realen Welt. Die meisten Argumente für Funktionen sind keine Kompilierzeitkonstanten, und viele Bedingungen sind auch zur Kompilierzeit nicht genau bekannt.

Eine solche Überladung zu spezifizieren und zu implementieren wäre eine erhebliche Menge an Arbeit, und sie würde nicht so viel verwendet werden. Wenn Sie über Begrenzungen und Argumente für die Kompilierungszeit verfügen, können Sie normalerweise die gesamte Funktion zum Zeitpunkt der Kompilierung auswerten, was bedeutet, dass eine Überladung nicht erforderlich ist.

Answer 2

Wenn ich verstehe, was Sie versuchen, richtig zu machen, ist die Funktionalität, die Sie anfordern, bereits verfügbar. Es ist nicht das eleganteste, aber ich denke, das ist gut genug.

Sie möchten eine Funktion zur Kompilierzeit und Laufzeit mit der gleichen Syntax aufrufen und wenn möglich zur Kompilierzeit auswerten, andernfalls sollte sie zur Laufzeit ausgewertet werden. Sie müssen Assertions für die Funktion unabhängig davon, wann sie aufgerufen wird, ausgewertet werden.

Ich glaube, dies wird tun, was Sie wollen:

constexpr int do_something(int x) 
{ 
    if(x <= 0) 
    { 
     std::cout << "x must be > 0" << std::endl; exit(-1); 
    } 
    return x + 5; 
} 

constexpr int compiletime_good = do_something(5); 
constexpr int compiletime_bad = do_something(0); // Fails at compile-time 

int runtime_good = do_something(5); 
int runtime_bad = do_something(0); // Fails at runtime 

constexpr int val_good = 5; 
constexpr int val_bad = 0; 

do_something(val_good); 
do_something(val_bad); // Fails at run-time 

int valrun_good = 5; 
int valrun_bad = 0; 

do_something(valrun_good); 
do_something(valrun_bad); // Fails at run-time 

Der Trick hier ist bei der Kompilierung in einer Art und Weise zu versagen, die nicht static_assert erfordert, und wird auch zur Laufzeit fehlschlagen.