Discussion :

[oodini]

Bonjour,

Je suis en train de mettre le nez dans le code de Boost::Interprocess, et suis tombé sur cette classe :

Code :

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

1
2
3
4
5
template<class MutexFamily, class VoidPointer, std::size_t MemAlignment>
class rbtree_best_fit
{
    ...
};

Jusque là, rien de particulier.

Dans un autre fichier, je tombe sur la déclaration anticipée suivante :

Code :

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

1
2
template<class MutexFamily, class VoidMutex = offset_ptr<void>, std::size_t MemAlignment = 0>
class rbtree_best_fit;

Comment se fait-il que soient apparus des valeurs par défaut non présente dans la définition de classe template originale ?

[koala01]

Salut,

Il faut savoir que la déclaration anticipée d'une classe template va avoir plusieurs objectif:

D'abord, comme toute déclaration anticipée, celui de faire savoir au compilateur que la classe existe, avec les paramètres template indiqués.

Ensuite, Les paramètres template suivent le même principe que les paramètres "classiques" au niveau des valeurs par défaut, à savoir que si tu déclares anticipativement une classe sous la forme de

Code :

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

1
2
template<class MutexFamily, class VoidMutex = offset_ptr<void>, std::size_t MemAlignment = 0>
class rbtree_best_fit;

le compilateur acceptera toute tentative de définition d'un objet de type rbtree_best_fit avec un, deux ou trois paramètres template.

Les "paramètres manquants" représenteront les types (ou valeur pour MemAlignment) représenté par les valeur par défaut.

Ansi, tu peux parfaitement déclarer des objets proches de

Code :

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

1
2
rbtree_best_fit<MonMutex>  tree;// équivalent à rbtree_best_fit<MonMutex,offset_ptr<void>, 0>
rbtree_best_fit<MonMutex, MonOffset>  tree; // équivalent à rbtree_best_fit<MonMutex, MonOffset, 0>

Seulement, la déclaration anticipée intervient dans le choix du "best match".

Autrement dit, si, pour une raison ou une autre, il n'existe pas de spécialisation partielle qui correspond d'avantage au type de données que tu vas déclarer, le compilateur va choisir la déclaration anticipée.

Seulement, la déclaration anticipée correspond alors à une classe vide, ce qui fait que dés que tu essayeras d'utiliser la moindre fonction (un constructeur ou n'importe quelle fonction définie dans les spécialisations partielles), tu risque de te retrouver avec une erreur de compilation t'indiquant que la dite fonction n'existe pas.

Ceci dit, il n'est pas du tout impossible, étant donné les problèmes que peuvent provoquer les références croisées, comme l'utilisation de fonctions propres à offset_ptr<void>, au niveau des fonctions inline que tu puisse trouver une spécialisation partielle proche de

Code :

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

1
2
3
4
template typename <class MutexFamily>
class rbtree_best_fit<MutexFamily, offset_ptr<void>, 0>{
   /* potentiellement pas mal de choses  */
};

dans un fichier *.tpp ou similaire.(je te rappelle que toutes les fonctions d'une classe template doivent a priori etre inline )

Ce fichier *.tpp sera alors sans doute inclus directement au niveau des fichiers d'implémentation qui ont recours au rbtree_best_fit et précédé du fichier dans lequel la classe offset_ptr est déclarée

[Flob90]

Le fichier de déclaration anticipé est inclus par le fichier de la définition. Les paramètres par défaut se cumulent sur l'ensemble des déclarations (et définition) présentes dans l'unité de compilation. Donc les paramètres par défaut sont bien toujours présents.

[oodini]

Je comprend bien ce que tu expliques, et je penses que je le savais déjà.
Ce que je ne comprend pas, c'est pourquoi la déclaration anticipée a certains de ses paramètres par défaut, et pas la définition de la classe.
Ou alors, je n'ai en fait pas compris ta réponse.

je te rappelle que toutes les fonctions d'une classe template doivent a priori etre inline

Pourquoi cela ?

[Flob90]

Pourquoi tu voudrais écrire deux fois les paramètres template par défauts ? A part risquer d'écrire deux listes différentes et donc produire un code invalide (*), ça n'apporte pas grand chose (qui ne puisse être apporté par ton EDI). Là les paramètres n'y sont qu'une fois, pas d'erreur possible.

(*) Mais même identique c'est invalide, cf message suivant.

[koala01]

Pourquoi cela ?

Parce qu'il faut que le code d'implémentation de la fonction soit disponible au moment de la compilation.

Du coup, à chaque fois que le compilateur rencontre une déclaration de variable pour laquelle les paramètres template sont fournis, il produira le code binaire correspondant.

Mais, à coté de cela, il y a le principe de la définition unique: il ne peut donc exister qu'une seul version du code binaire pour une fonction donnée, et donc une seule version du code binaire de la fonction spécialisée pour un type donné.

La seule exception à cette règle concerne les fonctions inline, pour lesquelles le code binaire correspondant peut exister en plusieurs versions.

Pour arriver à concilier ces deux points de vue, la seule solution passe par des fonctions inlines

[Klaim]

En fait, le truc qui est troublant c'est que C++ permet bien de definir les valeurs par defaut dans la declaration, et ce meme si il y a plusieurs declarations differentes avec des paramettres par defaut different.

Recemment sur son blog Herb Sutter a rappele que c'est une tres mauvaise idee d'utiliser des paramettre par defauts dans plus d'une declaration, et que c'est bien mieu si on peut completement eviter les paramettres par defaut.

[Flob90]

@koala01: Il y a plus d'une exception :

There can be more than one definition of [...] inline function [...] member function of a class template (14.5.1.1) [...] in a program provided that each definition appears in a different translation unit [...]

Il peut y avoir plus d'une définition [...] des fonctions inline [...] des fonctions membre d'une classe template [...] dans un programme pour peu que chaque définition soit dans une unité de compilation différente [...]

Donc le caractère inline n'est pas nécessaire (dans notre cas) en réalité.

@Klaim: Je suis pas certain d'avoir compris ton message, les paramètres par défaut pour un paramètre ne doivent pas être différents entre deux déclaration (définition), ni même identiques. Ceci est illégal :

Code :

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

1
2
3
 
template<class =int> struct A;
template<class =int> struct A {};

(la règle exact fait intervenir la notion de scope en plus)