Warum ist dies nicht ein konstanter Ausdruck?

In diesem trivialen Beispiel test2 nicht kompiliert werden, obwohl test1 gelingt, und ich sehe nicht, warum das der Fall ist. Wenn arr[i] geeignet ist für einen Rückgabewert aus einer Funktion markiert constexpr kann, warum kann es nicht verwendet werden als non-type template argument?

template<char c>
struct t
{ 
    static const char value = c;
};

template <unsigned N>
constexpr char test1(const char (&arr)[N], unsigned i)
{
    return arr[i];
}

template <unsigned N>
constexpr char test2(const char (&arr)[N], unsigned i)
{
    return t<arr[i]>::value;
}

int main()
{
   char a = test1("Test", 0); //Compiles OK
   char b = test2("Test", 0); //error: non-type template argument 
                              //is not a constant expression
}

Edit: Das macht keinen Unterschied:

template<char c>
struct t
{ 
    static const char value = c;
};

template <unsigned N>
constexpr char test1(const char (&arr)[N])
{
    return arr[0];
}

template <unsigned N>
constexpr char test2(const char (&arr)[N])
{
    return t<arr[0]>::value;
}

int main()
{
   char a = test1("Test"); //Compiles OK
   char b = test2("Test"); //error: non-type template argument 
                           //is not a constant expression
}

InformationsquelleAutor der Frage Chris_F | 2014-07-04

c++c++11 c++14 constexpr templates

20

Kurze Antwort: es gibt keine constexpr Parameter der Funktion in C++11/14.

Längere Antwort: in test1()wenn i ist nicht eine compile-Zeit-Konstante der Funktion ist noch brauchbar, zur Laufzeit. Aber in test2() es noch nicht kennt der compiler nicht, ob i ist eine compile-Zeit-Konstanten, und doch, es ist erforderlich für die Funktion zum kompilieren.

E. g. den folgenden code für test1 kompilieren wird
```
int i = 0;    
char a = test1("Test", i); //OK, runtime invocation of test1()

constexpr int i = 0;
constexpr char a = test1("Test", i); //also OK, compile time invocation of test1()
```
Lassen Sie uns einfach Ihre test2() zu
```
constexpr char test3(unsigned i)
{
    return t<i>::value;
}
```
Diese werden nicht kompiliert, für test3(0) denn im test3() es nicht bewiesen werden kann, dass i ist ein bedingungslose compile-Zeit-Ausdruck. Sie müssten constexpr Funktion der Parameter Ausdrücken zu können.

Zitat aus dem Standard

5.19 Konstante Ausdrücke [expr.const]

2 Ein bedingter-Ausdruck e ist ein core konstanter Ausdruck sein, es sei denn, die
evaluation von e nach den Regeln der abstrakten Maschine (1.9),
bewerten würde einer der folgenden Ausdrücke:

— id-Ausdruck, der bezieht sich auf eine variable oder Daten Mitglied
Referenz geben, es sei denn, die Referenz einer vorangegangenen Initialisierung und
entweder

— Initialisierung mit einer Konstanten Ausdruck oder

— es ist ein nicht-statischen Daten-member eines Objekts, dessen Leben begann in der Auswertung von e;

Diesem Abschnitt hat das folgende code-Beispiel entsprechend deiner Frage:
```
constexpr int f1(int k) {
    constexpr int x = k; //error: x is not initialized by a
                         //constant expression because lifetime of k
                         //began outside the initializer of x
    return x;
}
```
Weil x im obigen Beispiel, ist nicht ein konstanter Ausdruck sein, es bedeutet, dass Sie können nicht instanziieren von templates, die entweder mit x oder k innen f1.

InformationsquelleAutor der Antwort TemplateRex
7

Gibt es ein Missverständnis, was constexpr nicht hier. Es zeigt an, dass eine Funktion muss evaluatable zur compile-Zeit, für die passenden Argumente, aber es hat nicht entfernen Sie die Anforderung noch zu kompilieren, in den Allgemeinen Fall.

Nehmen wir die erste version:
```
template <unsigned N>
constexpr char test1(const char (&arr)[N], unsigned i) {
    return arr[i];
}
```
Nun, das ist ganz klar ein compile-time-Auswertung:
```
enum { CompileTimeConstant = test1("Test", 0) };
```
Ihrem Beispiel kann werden, aber es ist ein optimizer/QoI Problem:
```
char MayBeCompileTimeConstant = test1("Test", 0);
```
und diesem Beispiel offensichtlich nicht, aber ist noch erforderlich zu sein evaluatable
```
char arr[10];
int i;
std::cin >> i;
std::cin >> arr;
char b = test1(arr, i);
std::cout << "'" << arr << "'[" << i << "] = " << b << '\n';
```
Seit test2 können Sie möglicherweise nicht kompiliert die für den letzten Fall, kann es nicht kompilieren überhaupt. (Bitte beachten ich bin nicht was darauf hindeutet, dass code gute).

InformationsquelleAutor der Antwort Useless
2

Ist hier das problem, dass der Aufruf arr[i] erinnert an den subskript-operator operator[]. Dieser operator nicht wieder ein konstanter Ausdruck.

Es ist nicht ein problem der constexpr eigentlich ein problem von template-argument Abzug. Ein Nicht-Typ template-argument muss ein konstanter Ausdruck, der die Rückkehr argument der subskript-operator nicht.

Daher der compiler zu Recht beklagt, dass arr[i] ist nicht ein konstanter Ausdruck.

InformationsquelleAutor der Antwort 101010
1

Weil arr[i] ist keine Konstante zur Kompilierungszeit Ausdruck. Es kann auch anders laufen-Zeit.

InformationsquelleAutor der Antwort user1742529

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.

Zitat aus dem Standard