Discussion :

[PilloBuenaGente]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[ternel]

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

il faut procéder ainsi:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[PilloBuenaGente]

Bonjour Leternel, merci pour ta réponse.

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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..

[lautrec1]

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

[PilloBuenaGente]

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

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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;
}

[lautrec1]

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.

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

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

[PilloBuenaGente]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
struct Pos { const int pos; };
//------------------------------------------------------------------------------
int main()
{
    Quad();
    return 0;
}

tableau d'une case OK

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 }; }
};

[PilloBuenaGente]

Je n'avais pas suffisamment creusé..

En fait ceci ne compile pas non plus :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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é

[PilloBuenaGente]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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é !

[ternel]

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

Merci pour l'information