Comment affirmer statiquement une propriété commune de plusieurs classes

Question

Disons que j'ai 3 classes. Je m'attends à sizeof() chaque classe à être exactement les mêmes - disons 512 octets.

Comment puis-je utiliser quelque chose comme BOOST_STATIC_ASSERT à appliquer à tous tels que

1. Je ne dois utiliser BOOST_STATIC_ASSERT en un seul endroit (principe SEC)
2. ÉVALUÉ une fois à la compilation et non run-time

note: nous pouvons utiliser ce que C++ techniques que nous voulons (créer plus de classe, utiliser l'héritage, etc.)

Ma solution naïve est présentée ci-dessous:

class A { ...stuff }; BOOST_STATIC_ASSERT(sizeof(A) == 512); 
class B { ...stuff }; BOOST_STATIC_ASSERT(sizeof(B) == 512); 
class C { ...stuff }; BOOST_STATIC_ASSERT(sizeof(C) == 512); 

Answer 1

Cela semble fonctionner avec gcc 4.0.1 et stimuler 1,39:

template <typename T, size_t S> 
struct enforce_size 
{ 
    enforce_size() 
    { 
     BOOST_STATIC_ASSERT(sizeof(T) == S); 
    } 
}; 

class A: enforce_size<A,512> { /* stuff */ }; 
 

Answer 2

Comme ces classes ont aucune relation, je vois maintenant façon de le faire parce que vous devez être explicite sur les types de sorcières que vous voulez vérifier.

La seule manière DRY d'appliquer ceci est ce que Nikolai N Festissov a proposé. J'écrivais un exemple similaire avec quelques modifications mineures, mais l'idée globale est de faire une classe boost :: nocopy-like qui va forcer la classe enfant à avoir une taille donnée.

template< typename CheckedType, size_t FixedSize > 
class SizeChecked // simple, no inheritance overload 
{ 
public: 
    SizeChecked() 
    { 
     // c++0x or compilers with static_assert() available 
     //static_assert(sizeof(CheckedType) == FixedSize, "Type size check failed!"); 
     BOOST_STATIC_ASSERT(sizeof(CheckedType) == FixedSize); 
    } 

}; 

template< typename CheckedType > 
class Size512 : public SizeChecked< CheckedType, 512 > // simple, no inheritance overload 
{}; 

//////////////////////////////////////////////////////////////////// 

class A : Size512<A> // automatically check 
{ 
}; 


class B : Size512<B> // automatically check 
{ 
    std::array< char, 512 > m_array; 
}; 

class C : SizeChecked< C, 1 > 
{ 
    char m_char; 
}; 

class D : SizeChecked< D, 4 > 
{ 
    short m_k; 
    char m_u; 

}; 


int wmain() 
{ 
    // need instantiation to be checked ! 
    //A a; // will trigger the assertion at compile time 
    B b; // sizeof(B) == 512 : will be fine 
    C c; // sizeof(C) == 1 : will be fine 
    //D d; // will fail because sizeof(short) + sizeof(char) != 4 ! 

} 

Attention: si vous avez l'héritage libre vous reste à fournir un contrôle explicite sur les classes d'enfants, le chèque est pas hérité! A propos, une manière possible d'être plus DRY serait de mettre toutes vos affirmations statiques en un seul endroit.