Comment forcer automatiquement l'initialisation des membres statiques en C ?

Comment forcer automatiquement l'initialisation des membres statiques

Les membres statiques en C ne sont pas automatiquement initialisés à moins qu'ils ne soient utilisés d'une manière qui nécessite leur définition pour exister. Ce comportement peut parfois être gênant, en particulier lorsque vous souhaitez effectuer des effets secondaires lors de l'initialisation d'un membre statique.

Considérez l'exemple suivant :

<code class="cpp">template<class D>
char register_(){
    return D::get_dummy(); // static function
}

template<class D>
struct Foo{
    static char const dummy;
};

template<class D>
char const Foo<D>::dummy = register_<D>();

struct Bar
    : Foo<Bar>
{
    static char const get_dummy() { return 42; }
};</code>

Dans cet exemple, vous vous attendez à ce que le mannequin soit initialisé dès qu'il y a une instanciation concrète de Foo, que vous avez avec Bar. Cependant, ce n'est pas le cas en raison du comportement d'initialisation paresseux des membres statiques.

Pour forcer l'initialisation de dummy sans aucune instance de Bar ou Foo, vous pouvez utiliser l'une des techniques suivantes :

• Utiliser une spécialisation de modèle pour la classe dérivée : Cette technique consiste à créer une spécialisation de la classe modèle pour la classe dérivée et à initialiser manuellement le membre statique dans cette spécialisation.

<code class="cpp">template<class D>
struct Bar
    : Foo<Bar>
{
    static char const get_dummy() { return (void)dummy; return 42; }
};</code>

• Utiliser une structure de modèle pour forcer l'initialisation : Cette technique consiste à créer une structure de modèle qui force l'initialisation du membre statique via une variable membre de la structure de modèle.

<code class="cpp">template<typename T, T> struct value { };

template<typename T>
struct HasStatics {
  static int a; // we force this to be initialized
  typedef value<int&, a> value_user;
};

template<typename T>
int HasStatics<T>::a = /* whatever side-effect you want */ 0;</code>

• Utiliser une structure de modèle avec une union anonyme Enum : Cette technique est similaire à la précédente, mais elle utilise une union anonyme pour forcer l'initialisation du statique membres.

<code class="cpp">template<typename T, T> struct var { enum { value }; };
typedef char user;

template<typename T>
struct HasStatics {
  static int a; // we force this to be initialized
  static int b; // and this

  // hope you like the syntax!
  user :var<int&, a>::value,
       :var<int&, b>::value;
};

template<typename T>
int HasStatics<T>::a = /* whatever side-effect you want */ 0;

template<typename T>
int HasStatics<T>::b = /* whatever side-effect you want */ 0;</code>

Ces techniques vous permettent de forcer l'initialisation des membres statiques sans nécessiter l'intervention de l'utilisateur ni modifier la classe dérivée. La technique spécifique à utiliser dépendra de vos besoins spécifiques et de vos préférences en matière de style de codage.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!