Accès à un tableau static constexpr

Bonjour,

Je n'arrive pas à comprendre un truc "bizarre" dans ces conditions bien particulières.

J'ai épuré au maximum le code, quelqu'un pourrait-il, s'il vous plait, m'expliquer pourquoi le compilo me balance : undefined reference to `Quad::tab' pour ce code :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14

struct Pos { int pos; }; //------------------------------------------------------------------------------ struct Quad { Quad() { foo(); } static constexpr Pos tab[1] = {{ 1 }}; void foo() { Pos copy = tab[0]; } }; //------------------------------------------------------------------------------ int main() { Quad(); return 0; }

---

Merci.

Oui, la définition d'une variable statique ne peut pas être dans la déclaration du type.

il faut procéder ainsi:

Code:

---

1 2 3 4 5

class A { static const int i; }   const int A::i = 1;

---

Qui plus est, la définition de la variable statique ne peut apparaître que dans une unique unité de compilation, donc pas dans un en-tête.
Cela dit, dans ton exemple simplifiée, c'est bien le cas.

Bonjour Leternel, merci pour ta réponse.

Mais j'ai c++11, et je peux déclarer les membres en static constexpr :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

#include <iostream> //------------------------------------------------------------------------------ struct Struct { static constexpr int tab[4] = { 1, 2, 3, 4 }; }; //------------------------------------------------------------------------------ int main() { std::cout << Struct::tab[3]; return 0; }

---

console: 4

Cependant, avec le cas précis du code plus haut, c'est impossible.. :?

La signification par défaut de chaque opération générée, comme implémentée telle que le compilateur la génère, est d'appliquer l'opération à tous les membres de base et non-statiques de la classe.

(Source: Dans la 4è édition de Stroustrup (p519) : 17.6 Generating default operations)

tab[0] est statique.

En espérant t'aider, même s'il y a peu de chances

Merci à toi Lautrec1, j'avoue ne pas saisir le sens de cette phrase.. :oops:

Le problème ne semble pas être seulement dû au static vu que ce code complie :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14

struct Pos { int pos; }; //------------------------------------------------------------------------------ struct Quad { Quad() { foo(); } static constexpr Pos pos = { 1 }; void foo() { Pos copy = pos; } }; //------------------------------------------------------------------------------ int main() { Quad(); return 0; }

---

Ca ne t'aide donc pas.
En effet dans un livre de 2000 et moins bien côté:
"Le compilateur génère un opérande d'affectation par défaut, c'est-à-dire une fonction membre opérateur correspondante publique, à condition que la classe contienne des membres non statiques, constantes ou références"
Ca doit donc marcher ici.

Citation:

---

Envoyé par PilloBuenaGente

Merci à toi Lautrec1, j'avoue ne pas saisir le sens de cette phrase.. :oops:

---

Je te mets la version en VO,pour être complet.

"By default, a class provides:
- A default constructor
- A copy constructor
- A copy assignment
- A move constructor
- A move assignment
- A destructor

The default meaning of each generated operation, as implemented when the compiler generates it, is to apply the operation to each base and non-static data member of the class. That is, we get memberwise copy, memberwise default construction, etc..."

L'extrait de Stoustrup ne précise pas ce qui se passe si un seul membre de la classe est static.

EDIT : orthographe

Merci à toi de ne pas perdre patience..
Ce coup ci je pense avoir compris ;)
La classe en question ne rentre donc pas dans ces critères.. :?

Edit : Je me suis permis de changer le titre, car ce n'est pas seulement pour une copie, mais même pour un simple accès ça bloque..

Le problème se déplace...

Pour la même classe Pos et le même main :

Code:

---

1 2 3 4 5 6 7 8

struct Pos { const int pos; }; //------------------------------------------------------------------------------ int main() { Quad(); return 0; }

---

tableau d'une case OK

Code:

---

1 2 3 4 5 6

struct Quad { Quad() { foo(1, 0); } static constexpr Pos tab[1] = {{ 1 }}; Pos foo(const int pos, const int index) { return { pos + tab[index].pos }; } };

---

plusieurs cases ERROR

Code:

---

1 2 3 4 5 6

struct Quad { Quad() { foo(1, 0); } static constexpr Pos tab[2] = {{ 1 }, { 2 }}; Pos foo(const int pos, const int index) { return { pos + tab[index].pos }; } };

---

mais avec un accès par constexpr OK

Code:

---

1 2 3 4 5 6

struct Quad { Quad() { foo(1); } static constexpr Pos tab[2] = {{ 1 }, { 2 }}; Pos foo(const int pos) { return { pos + tab[1].pos }; } };

---

:arf:

Je n'avais pas suffisamment creusé..

En fait ceci ne compile pas non plus :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

struct Quad { Quad() { foo(1, 0); } static constexpr int tab[3] = { 1, 2, 3 }; int foo(const int pos, const int index) { return { pos + tab[index] }; } }; //------------------------------------------------------------------------------ int main() { Quad(); return 0; }

---

C'est donc; l'accès à un tableau constexpr doit ce faire avec une valeur constexpr.

Ceci n'était pas viable, sans doute que le compilo transforme ce tableau en simple valeur.

Code:

---

1 2 3 4 5 6

struct Quad { Quad() { foo(1, 0); } static constexpr Pos tab[1] = {{ 1 }}; // Ce traduit par un simple static constexpr Pos tab = { 1 }; Pos foo(const int pos, const int index) { return { pos + tab[index].pos }; } };

---

Merci du temps passé en tout cas !

edit dois-je rechanger le titre du post ?
reedit changé 8-)

Du nouveau !

En cherchant "static array constexpr" je suis tombé sur ça.

Il suffit juste de déclarer ce membre dans l'espace global.(Comme le faisait remarqué Leternel, sauf qu'avec static constexpr, on peut le définir au sein de la classe).

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13

struct Quad { Quad() { foo(1, 0); } static constexpr int tab[3] = { 1, 2, 3 }; int foo(const int pos, const int index) { return { pos + tab[index] }; } }; constexpr int Quad::tab[3]; //------------------------------------------------------------------------------ int main() { Quad(); return 0; }

---

Sauvé !

Je m'en souviendrai, c'est intéressant.

Merci pour l'information