initialiser un const tableau dans une classe d'initialiseur en C++

Avec C++11 la réponse à cette question a maintenant changé et vous pouvez en fait faire:

struct a {
    const int b[2];
    //other bits follow

    //and here's the constructor
    a();
};

a::a() :
    b{2,3}
{
     //other constructor work
}

int main() {
 a a;
}

std::vector utilise le tas. Waow, quel gâchis ce serait juste pour le plaisir d'un const la santé mentale-case. Le point de std::vector est une dynamique de croissance au moment de l'exécution, et non pas un vieux de la vérification de syntaxe qui doit être fait au moment de la compilation. Si vous n'allez pas à grandir alors créer une classe pour envelopper un tableau normal.

#include <stdio.h>
template <class Type, size_t MaxLength>
class ConstFixedSizeArrayFiller {
private:
size_t length;
public:
ConstFixedSizeArrayFiller() : length(0) {
}
virtual ~ConstFixedSizeArrayFiller() {
}
virtual void Fill(Type *array) = 0;
protected:
void add_element(Type *array, const Type & element)
{
if(length >= MaxLength) {
//todo: throw more appropriate out-of-bounds exception
throw 0;
}
array[length] = element;
length++;
}
};
template <class Type, size_t Length>
class ConstFixedSizeArray {
private:
Type array[Length];
public:
explicit ConstFixedSizeArray(
ConstFixedSizeArrayFiller<Type, Length> & filler
) {
filler.Fill(array);
}
const Type *Array() const {
return array;
}
size_t ArrayLength() const {
return Length;
}
};
class a {
private:
class b_filler : public ConstFixedSizeArrayFiller<int, 2> {
public:
virtual ~b_filler() {
}
virtual void Fill(int *array) {
add_element(array, 87);
add_element(array, 96);
}
};
const ConstFixedSizeArray<int, 2> b;
public:
a(void) : b(b_filler()) {
}
void print_items() {
size_t i;
for(i = 0; i < b.ArrayLength(); i++)
{
printf("%d\n", b.Array()[i]);
}
}
};
int main()
{
a x;
x.print_items();
return 0;
}

ConstFixedSizeArrayFiller et ConstFixedSizeArray sont réutilisables.

La première permet d'exécution de la vérification de limites lors de l'initialisation de la matrice (même comme un vector), qui peut par la suite devenir const après cette initialisation.

Le second permet la matrice soit alloué à l'intérieur de un autre objet, qui pourrait être sur le tas ou tout simplement la pile si c'est l'emplacement de l'objet. Il n'y a pas de perte de temps de l'allocation dans le tas. Il effectue également au moment de la compilation const vérifier sur le tableau.

b_filler est un petit cours privé pour fournir les valeurs d'initialisation. La taille de la matrice est vérifié au moment de la compilation avec les arguments de modèle, donc il n'y a aucune chance de sortir des limites du terrain.

Je suis sûr qu'il y a de plus exotique des moyens de modifier cette. C'est un premier coup de couteau. Je pense que vous pouvez très bien faire pour tout le compilateur de la lacune de classes.

Où j'ai une constante tableau, il a toujours été fait comme statique. Si vous pouvez accepter que, ce code doit être compilé et exécuté.

#include <stdio.h>
#include <stdlib.h>
class a {
static const int b[2];
public:
a(void) {
for(int i = 0; i < 2; i++) {
printf("b[%d] = [%d]\n", i, b[i]);
}
}
};
const int a::b[2] = { 4, 2 };
int main(int argc, char **argv)
{
a foo;
return 0;
}

Une solution sans utiliser le tas avec std::vector est d'utiliser boost::array, si vous ne pouvez pas initialiser les membres du groupe directement dans le constructeur.

#include <boost/array.hpp>
const boost::array<int, 2> aa={ { 2, 3} };
class A {
const boost::array<int, 2> b;
A():b(aa){};
};

il est intéressant de noter, en C# vous avez le mot-clé const, qui se traduit par C++static const, par opposition à la lecture seule qui ne peut être que définie à des constructeurs et des initialisations, même par les non-constantes, ex:

readonly DateTime a = DateTime.Now;

Je suis d'accord, si vous avez un const pré-définis ensemble que vous pourriez faire ainsi de l'électricité statique.
À ce stade, vous pouvez utiliser cette intéressante syntaxe:

//in header file
class a{
static const int SIZE;
static const char array[][10];
};
//in cpp file:
const int a::SIZE = 5;
const char array[SIZE][10] = {"hello", "cruel","world","goodbye", "!"};

cependant, je n'ai pas trouvé un moyen de contourner la constante '10'. La raison en est claire, il a besoin d'elle pour savoir comment faire accéder à la matrice. Une alternative possible est d'utiliser des #define, mais je n'aime pas cette méthode et j' #undef à la fin de l'en-tête, avec un commentaire à modifier il y a au RPC et dans le cas où si un changement.