Discussion :

[Luc Hermitte]

Je préfère quand même utiliser des nombres non signés et commencer mon énumération à zéro, au lieu de faire un tas de grigis (surtout avec des nombres négatifs à moins qu'il y ait une feinte)

Quel nombre négatif ? Il n'y en a pas un seul. La plupart des feintes sont ailleurs -- non décrites dans l'article. Il reste ici, uniquement __MAX qui est automatiquement positionné à ce que std::extent/array_size() retournera. Ce qui permet d'enchainer sur un static_assert/BOOST_STATIC_ASSERT/LOKI_STATIC_ASSERT/...

[foetus]

Quel nombre négatif ? Il n'y en a pas un seul. La plupart des feintes sont ailleurs -- non décrites dans l'article. Il reste ici, uniquement __MAX qui est automatiquement positionné à ce que std::extent/array_size() retournera. Ce qui permet d'enchainer sur un static_assert/BOOST_STATIC_ASSERT/LOKI_STATIC_ASSERT/...

Je viens de vérifier enum Type { one, two, three, MAX__, UNDEFINED__, FIRST__=0 };
C'est le FIRST__=0 qui m'a induit en erreur.

Donc c'est la même proposition que moi mais avec un UNDEFINED__ et un FIRST__=0 (est-il vraiment utile? ) en plus

[Luc Hermitte]

Oui, mais on sort du sujet, bien que cela soit un truc que je voudrais décrire à l'occasion.

Il y a bien un intérêt. Ce code est généré automatiquement.
FIRST__ et MAX__ me servent à alimenter deux fonctions au doux noms de begin() et end(), Voire un type Range (si mon vim détecte que je bosse en C++11). De là, j'ai un type compatible avec les range based for loops du C++11, ou juste avec un autre snippet d'itération sur l'énum: https://code.google.com/p/lh-vim/wik...Enum_iteration
Quant à UNDEFINED, je m'en sers pour supporter parfois un constructeur par défaut qui nous positionne dans un état indéfini -- je n'ai rien trouvé de mieux qui soit compatible avec ma religion: http://cpp.developpez.com/faq/cpp/?p...iables-locales.

De retour au sujet des tailles de tableaux, je suis opposé :
- au sizeof()/sizeof() qui peut accepter des pointeurs par mégarde (et donc compiler en n'importe quoi),
- et au "tab[TAILLE] = {...}" qui est non DRY, et qui ne peut même pas vérifier qu'il y a bien TAILLE éléments dans la liste entre accolades.

On a des solutions sécurisées, qui coutent peu en temps de dév (snippet, wizards, copier-coller d'un projet à l'autre, ...), et qui ne coutent rien en temps d'exécution. Pourquoi s'en priver ?

[LittleWhite]

Car la solution proposée n'a pas été comprise. Surtout l'histoire d'include (oui, je ne parle pas le template couramment).

[Invité]

Salut.

L'initialisation de ton tableau statique sur ton const char doit se faire dans un fichier.cpp ou bien après la déclaration de ta classe dans ton fichier.h (donc, dans une autre unité de compilation), seule l'initialisation des constantes statiques sur des entiers peut se faire dans la même unité de compilation.

Je ne pense pas qu'il y ai vraiment d'autre solution en c++98 que de rajouter un -flto.

[foetus]

- et au "tab[TAILLE] = {...}" qui est non DRY, et qui ne peut même pas vérifier qu'il y a bien TAILLE éléments dans la liste entre accolades.

Juste pour t'horrifier j'ai trouvé une solution C pour lier les énumérations (qui représente en gros les indices) aux valeurs/ objets dans le tableau
Regarde bien Defs.cpp

Defs.h:

Code :

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

1
2
3
4
5
6
7
8
9
10
class Test
{
public:
 
    enum { OPTION1 = 0, OPTION2, OPTION3, NB_OPTIONS };
 
    static const char* pC[];
 
    static const size_t size;
};

Defs.cpp:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
#include <cstddef>
 
#include "Defs.h"
 
 
const char* Test::pC[] = {
    [OPTION1] = "lol",
    [OPTION2] = "lil",
    [OPTION3] = "lul"};
 
const size_t Test::size = NB_OPTIONS;

main.cpp:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include<iostream>
 
#include"Defs.h"
 
 
int main()
{
    Test test;
 
    std::cout << "Nb Options: " << test.size << std::endl;
 
    for(size_t option = Test::OPTION1; option < test.size /* Test::NB_OPTIONS */; option++) {
        std::cout << "Option " << option << ": " << test.pC[option] << std::endl;
    }
 
    return 0;
}

[the Hound]

Salut.

L'initialisation de ton tableau statique sur ton const char doit se faire dans un fichier.cpp ou bien après la déclaration de ta classe dans ton fichier.h (donc, dans une autre unité de compilation), seule l'initialisation des constantes statiques sur des entiers peut se faire dans la même unité de compilation.

Je ne pense pas qu'il y ai vraiment d'autre solution en c++98 que de rajouter un -flto.

Attention pas toto.cpp ou tata.cpp hein, fichier.cpp sinon ça marche pas

Plus sérieusement, tu n'as pas compris le principe des unités de compilation, Lolilolight.
Il y a une unité de compilation par fichier .cpp. Tous les fichiers inclus par un fichier .cpp : .h, .hpp, .tpp ou tout ce que tu veux, font partie de cette unité de compilation.
Ensuite je suis curieux de voir comment tu résous son problème avec ta solution ...

[Luc Hermitte]

@LittleWhite, tu mets le coeur du fichier array_helper.hpp dans un fichier de ton choix (ou tu utilises l'équivalent qui existe chez boost si mes souvenirs sont bons). Et tu utilises ensuite la macro array_size() sur ta variable de type tableau. Et c'est aussi simple que cela.
Si c'est pour des enums. Si tu utilises vim, avec mes plugins, tu généras de façon assez magique ce genre de choses (je donne le résultat en mode < 2011):

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
//MyEnum.hpp
/**
 * MyEnum Safe Enum.
 * 
 * This snippet has been automatically generated with vim plugin mu-template.
 * 
 * «doc»
 * 
 * @invariant 
 * 
 * @version $revision$
 * @author «author-name»
 * <b>Licence</b>
 * BSD 3 clauses (http://opensource.org/licenses/BSD-3-Clause)
 * Copyright (c) 2014, Luc Hermitte (snippet author)
 * Copyright (c) 2014, Luc Hermitte <EMAIL:hermitte {at} free {dot} fr>
 * All rights reserved.
 * 
 * Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
 * 
 * 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
 * 
 * 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
 * 
 * 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
 * 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include <string>
#include <stdint.h>
#include <cassert>
#include <stdexcept>
struct MyEnum {
    enum Type { un, deux, trois, quatre, MAX__, UNDEFINED__, FIRST__=0 };
 
    explicit MyEnum(uint8_t value)
        : m_value(Type(value))
        {
            if (value >= MAX__) {
                throw std::runtime_error("Invalid MyEnum value");«»
            }
        }
    MyEnum(Type value)
        : m_value(Type(value)) {
            assert(m_value < MAX__);
        }
    MyEnum()
        : m_value(UNDEFINED__) {}
    MyEnum(std::string const& s);
    MyEnum& operator++() {
        assert(m_value < MAX__);
        m_value = MyEnum::Type(m_value+1);
        return *this;
    }
    MyEnum operator++(int) {
        MyEnum tmp = *this;
        ++*this;
        return tmp;
    }
 
    char const* toString() const;
    Type toInternal() const { return m_value; }
    friend bool operator<=(MyEnum lhs, MyEnum rhs) { return lhs.m_value <= rhs.m_value; }
    friend bool operator>=(MyEnum lhs, MyEnum rhs) { return lhs.m_value >= rhs.m_value; }
    friend bool operator< (MyEnum lhs, MyEnum rhs) { return lhs.m_value <  rhs.m_value; }
    friend bool operator> (MyEnum lhs, MyEnum rhs) { return lhs.m_value >  rhs.m_value; }
    friend bool operator==(MyEnum lhs, MyEnum rhs) { return lhs.m_value == rhs.m_value; }
    friend bool operator!=(MyEnum lhs, MyEnum rhs) { return lhs.m_value != rhs.m_value; }
 
    static MyEnum max  () { return MyEnum(build_max()); }
    static MyEnum begin() { return FIRST__; }
    static MyEnum end  () { return MyEnum(build_max()); }
 
private:
    struct build_max{};
    MyEnum(build_max) : m_value(MAX__){}
 
    Type m_value;
};

Code C++ :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
//MyEnum.cpp
#include "MyEnum.hpp" 
#include <algorithm>
#include <stdexcept>
#include <boost/range/begin.hpp>
#include <boost/range/end.hpp>
#include <boost/static_assert.hpp>
namespace  { // Anonymous namespace
    typedef char const* const* strings_iterator;
    static char const* const MYENUM_STRINGS[] =
    { "un", "deux", "trois", "quatre" };
} // Anonymous namespace //  namespaces
 
 
MyEnum::MyEnum(std::string const& s)
{
    strings_iterator const MyEnum_it = std::find(boost::begin(::MYENUM_STRINGS),boost::end(::MYENUM_STRINGS), s);
    if (MyEnum_it == boost::end(::MYENUM_STRINGS)) {
        throw std::runtime_error("Cannot decode MyEnum name `"+s+"`");
    }
    m_value = Type(std::distance(boost::begin(::MYENUM_STRINGS), MyEnum_it));
    assert(m_value < MAX__);
}
 
// ----------------- >% -----------------
// A mettre dans un .h à part
// Parfois on a besoin d'une constante de compilation ;
// dans ce cas la solution suivante est applicable :
// Falk Tannhäuser, fclc++, 
//   Message-ID: <3FCB378C.1A1C6066@crf.canon.fr>
namespace  {
    template <std::size_t N>
        struct array { char value[N]; };
 
    template<typename T, std::size_t N>
        array<N> array_size_helper(T (&)[N]);
} // namespace 
#define array_size(array) (sizeof ::array_size_helper(array).value)
// ----------------- >% -----------------
 
char const* MyEnum::toString() const
{
    BOOST_STATIC_ASSERT(MAX__ == array_size(::MYENUM_STRINGS));
    assert(m_value != UNDEFINED__); // Yes, I know UNDEFINED__ > MAX__
    assert(m_value < MAX__);
    return MYENUM_STRINGS[m_value];
}

[ternel]

Salut.

L'initialisation de ton tableau statique sur ton const char doit se faire dans un fichier.cpp ou bien après la déclaration de ta classe dans ton fichier.h (donc, dans une autre unité de compilation), seule l'initialisation des constantes statiques sur des entiers peut se faire dans la même unité de compilation.

Je ne pense pas qu'il y ai vraiment d'autre solution en c++98 que de rajouter un -flto.

Pour être précis, une unité de compilation, c'est le résultat du passage du préprocesseur dans un fichier à compiler.
Confère les détails sur le processus de compilation dans la norme.

[Invité]

Ha ok autant pour moi je n'avais pas compris.

Mais pourquoi tu ne fais pas un truc de ce goût là ?

Code cpp :

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

1
2
3
4
5
6
7
8
9
10
11
 
class Test {
         public :
         static const char[] array;
         static std::size_t size;
};
const char[] Test::array = {'1', '2', '3'};
std::size_t Test::size = sizeof(array);
int main(int argv, char[] argc*) {
     std::cout<<"size : "<<Test::size<<std::endl;
}

?

Excuse moi mais je ne vois pas du tout le sens de ton code.
Mais bon puisque tu étais impatient de voir ma solution.

[ternel]

Parce qu'il s'agit de mettre la déclaration dans un en-tête, qui sera inclus dans plusieurs unités de compilations différentes.

Donc qu'il y a le risque d'avoir deux déclarations de la même variable lors du linkage.

[Invité]

Ha, ok, le fichier.h n'est pas inclus qu'une seule fois alors, je n'ai jamais fais ça, et je ne vois pas de trop l'intérêt de le faire.
Chaque header ne devrait être inclus qu'une seule fois.

A part que tu vas te retrouver avec plusieurs déclarations pour une même classe, ce qui va résulter soit en une erreur de compilation ou bien un crash.

Pourquoi tu ne mets pas ce code dans les différents fichier .cpp qui inclue ton .h dans ce cas là ?

Code cpp :

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

1
2
3
 
const char[] Test::array = {'1', '2', '3'};
std::size_t Test::size = sizeof(array);

[Luc Hermitte]

Avez-vous vraiment besoin de décapsuler le tableau et d'y donner un accès depuis n'importe où ?

[the Hound]

Ha, ok, le fichier.h n'est pas inclus qu'une seule fois alors, je n'ai jamais fais ça, et je ne vois pas de trop l'intérêt de le faire.
Chaque header ne devrait être inclus qu'une seule fois.

Ça suffit les âneries, va donc revoir les bases ...

A part que tu vas te retrouver avec plusieurs déclarations pour une même classe, ce qui va résulter soit en une erreur de compilation ou bien un crash.

Pourquoi tu ne mets pas ce code dans les différents fichier .cpp qui inclue ton .h dans ce cas là ?

Code cpp :

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

1
2
3
 
const char[] Test::array = {'1', '2', '3'};
std::size_t Test::size = sizeof(array);

Tu sais, s'il y a eu ce nombre d'intervenants et de posts sur ce thread tu te doutes bien que la solution est pas si simple ... ou au moins pas aussi simple que tu sembles penser.
PS: Juste au cas où parce qu'à force tu dois avoir l'impression que je fais que te descendre sans argumenter. Ta solution n'est pas une solution. Si on rajoute un élément au tableau, il faudra le faire sur tous les .cpp ?

[ternel]

Ha, ok, le fichier.h n'est pas inclus qu'une seule fois alors, je n'ai jamais fais ça, et je ne vois pas de trop l'intérêt de le faire.
Chaque header ne devrait être inclus qu'une seule fois.

A part que tu vas te retrouver avec plusieurs déclarations pour une même classe, ce qui va résulter soit en une erreur de compilation ou bien un crash.

Pourquoi tu ne mets pas ce code dans les différents fichier .cpp qui inclue ton .h dans ce cas là ?

Code cpp :

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

1
2
3
 
const char[] Test::array = {'1', '2', '3'};
std::size_t Test::size = sizeof(array);

Sans blague?
et <iostream> tu ne l'inclue pas dans plusieurs unité de compilation, par hasard? genre main.cpp et maClasseSuper.cpp?

Et pourquoi voudrais-tu mettre du code dans plusieurs fichiers?
Pour déclarer plusieurs variables différentes?
C'est l'inverse de ce qu'il faut faire.
Et l'inverse du concept même de variable globale. (contre lequel je suis déjà assez remonté en C++, on a déjà les classes et un main pour déclarer à l'ouverture)

[Invité]

Sans blague?
et <iostream> tu ne l'inclue pas dans plusieurs unité de compilation, par hasard? genre main.cpp et maClasseSuper.cpp?

Oui, le fichier .h peut être inclus dans plusieurs classes, mais son contenu n'est inclus qu'une seule fois.

Code cpp :

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

1
2
3
4
5
 
#ifndef FILE_HPP
#define FILE_HPP
//Contenu du fichier.
#endif

A la fin du passage du préprocesseur il n'y a plus qu'un seul fichier!

T'a qu'à faire une macro alors que tu redéfinis avant l'inclusion du fichier.h dans ton .cpp, là tu peux faire plusieurs déclarations différentes. (J'avais fait ça une fois.)
Mais de toute façon, le contenu de ce fichier là ne sera inclus qu'une seule fois :

Code cpp :

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

1
2
3
4
5
6
7
8
9
10
11
 
#ifndef TEST_HPP
#define TEST_HPP
class Test {
       //Définition de la classe ici.
       static const char[] tab;
       static std::size_t size;
};
char[] Test::tab = {'1', '2', '3'};
size_t Test::size = sizeof(tab);
#endif

Donc non, il n'y aura pas plusieurs déclarations différentes ni d'erreur au linkage. (et ils sont dans la même unité de compilation)
Je le sais bien, je fais ça dans ma bibliothèque et j'inclus bien le fichier.h à plusieurs endroits.
Mais bon peut être n'ai je pas bien cerné le problèmes car quand je vois le nombre de posts pour ça..., ça doit sûrement être plus complexe que ça.
Et perso j'inclus les .h dans les .h et ensuite j'inclus le .h de la classe dans le .cpp de la classe ainsi j'ai pas à include tout les .h dans les .cpp. (Sauf en cas d'inclusion cyclique ou là je fais autrement)

[the Hound]

...

Code :

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

1
2
3
4
5
6
7
// header.h
#ifndef TOTO
#define TOTO
 
int a;
 
#endif

Code :

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

1
2
// a.cpp
#include "header.h"

Code :

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

1
2
// b.cpp
#include "header.h"

Je te suggère de faire le test.

[Invité]

Ho et puis zut, suffit juste de savoir comment faire les includes hein :

Code cpp :

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

1
2
3
4
5
6
7
8
9
10
 
//test.h
#ifndef TEST_HPP
#define TEST_HPP
class Test {
       //Définition de la classe ici.
       static const char[] tab;
       static std::size_t size;
};
#endif

Code cpp :

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

1
2
3
4
 
//test.impl
char[] Test::tab = {'1', '2', '3'};
size_t Test::size = sizeof(tab);

Code cpp :

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

1
2
3
4
 
//a.cpp
#include "test.h"
#include "test.impl"

Code cpp :

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

1
2
3
4
 
//b.cpp
#include "test.h"
#include "test.impl"

Ca va pas ça ?

[the Hound]

Tu as testé avant de répondre ?

[Invité]

J'ai dit que je faisais ça dans ma bibliohtèque et là ça marche.

Donc oui j'ai testé.