Puis-je faire une erreur de compilation sur « trop peu initialisations »?

Question

J'utilise un initialiseur agrégat de mettre en place un bloc de données statiques pour un test unitaire.

Je voudrais utiliser la taille du tableau que le nombre prévu d'éléments, mais cela peut échouer si trop peu initialiseurs sont fournis:

my_struct_type expected[14] =
{
    { 1.234, 0, 'c' },
    { 3.141, 1, 'z' },
    { 2.718, 0, 'a' }
};

Cela donne aucune erreur de compilateur dans Visual Studio 2008.

Je voudrais pouvoir l'utiliser comme tel:

const unsigned expected_size = sizeof(expected) / sizeof(my_struct_type);

BOOST_CHECK_EQUAL(points.size(), expected_size);

for( int i = 0; i < expected_size; i++ )
{
    BOOST_CHECK_EQUAL(points[i].value, expected[i].value);
    BOOST_CHECK_EQUAL(points[i].count, expected[i].count);
    BOOST_CHECK_EQUAL(points[i].sym,   expected[i].sym);
}

mais parce que je n'ai pas une garantie de compilation de 14 points, cela va au large de la fin du tableau fin des ont fourni des valeurs et dans les valeurs par défaut initialisé.

Puis-je appliquer en quelque sorte le nombre de tableaux globaux initializers à la compilation?

Answer 1

Première: Il est peut-être un avertissement pour cela. Avez-vous essayé de compiler au niveau d'alerte le plus élevé?

Alors: Si vous échangez dont la valeur est calculée et qui est littéral, vous pouvez élever une erreur de compilation:

my_struct_type my_array[] = // <== note the empty []
{
    { 1.234, 0, 'c' },
    { 3.141, 1, 'z' },
    { 2.718, 0, 'a' }
};

BOOST_STATIC_ASSERT( sizeof(my_array)/sizeof(my_array[0]) == 14 );

Answer 2

En fait, il ne fonctionnera pas à l'extrémité du tableau, car le compilateur par défaut initialiser tous les éléments du tableau que vous ne vous êtes pas initialisez.

Si vous essayez de vous assurer que vous disposez d'un numéro spécifique des initialisations configurés, je ne sais pas comment faire.

Si vous voulez juste vous assurer que le tableau est le nombre d'articles que vous avez:

my_struct_type expected[] =
{
    { 1.234, 0, 'c' },
    { 3.141, 1, 'z' },
    { 2.718, 0, 'a' }
};

fera l'affaire. Ensuite, il suffit d'utiliser sizeof(expected) / sizeof(expected[0]) pour obtenir le nombre total d'éléments du tableau.

Answer 3

Juste pour l'amour d'une réponse non-Boost ...

Vous pouvez ajouter une exigence d'initialisation en modifiant my_struct_type.

template< typename T >
struct must_be_initialized {
    T value;

    must_be_initialized( T const &v ) : value( v ) {}
     // no default constructor!

    operator T& () { return value; }
    operator T const& () const { return value; }
};

struct my_struct_type {
    must_be_initialized< double > f;
    int i;
    char c;
};

my_struct_type expected[14] =
{
    { 1.234, 0, 'c' },
    { 3.141, 1, 'z' },
    { 2.718, 0, 'a' }
     // error: no default constructor exists
};

my_struct_type est encore un agrégat, mais pas POD.

Answer 4

ISO / CEI 14882 (Première édition 1998-09-01) en p. 8.5.1.7 indique ce qui suit:

  

S'il y a moins initializers dans la   liste que il y a des membres dans le   ensemble, chaque élément non   explicitement initialisé doit être   default-initialisé (8,5). [Exemple:   struct {int S a; char * b; int c; }; S   ss = {1, "asdf"}; Initialise ss.a   avec 1, ss.b avec "asdf", et ss.c   avec la valeur de l'expression de la   forme int (), qui est, 0.]

Simplement, la réponse à votre question est non.

Answer 5

Selon le msdn, si moins initialiseurs sont spécifiés, les autres éléments sont initialisés avec 0, de sorte que le code devrait fonctionner quand même.