Paramètres template par défaut

Bonjour,

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

Code:

---

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:

---

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 ?

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:

---

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:

---

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:

---

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 :D)

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 ;)

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.

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. :)

Citation:

---

Envoyé par koala01

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

---

Pourquoi cela ?

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.

Citation:

---

Envoyé par oodini

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 ;)

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.

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

Citation:

---

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 [...]

---

Citation:

---

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:

---

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)

Ok alors je suis un peu perdu sur les details dans ce cas. Peut etre que je melange avec les parametres par defaut d'arguments de fonction plutot.

@Klaim: Non, pareil pour les arguments pas défaut des fonctions, une seule et unique fois. En faite il y a une nuance si tu changes de scope entre deux déclarations de la même fonction, mais c'est franchement tordue comme utilisation.

Par contre tu peux définir plusieurs arguments par défaut entre différentes déclarations, tant que c'est pas pour les mêmes paramètres. Dans ce cas ils se cumulent.

En gros, vous êtes en train de me dire que si un .h définit une fonction, et que 10 fichiers font une déclaration de cette fonction, n'importe laquelle peut se charger de définir les valeurs par défaut pour cette fonction ?

On est en train de te dire que ca peut devenir vicieux oui :aie:

Oui on peut avoir des choses très spécial en le voulant. Mais au final retenir : argument par défaut lors de la première déclaration, donc dans le fichier de déclarations anticipées si tu en fais un, c'est encore le plus simple.

Bon, he bien je me résous à ce qui m'apparaît comme un défaut du C++. :(

Pourquoi ça serait un défaut ? Tu trouves pas que ce serait justement contraignant de devoir les réécrire à chaque fois ? Au risque de se tromper ?

Il y a plein de règles du C++ qui permettent de faire des choses étranges, mais l'idée de base derrière est souvent simple et dans l'esprit du principe de moindre surprise.

Ben on est obligé de faire une recherche de déclarations dans tout le projet pour savoir s'il existe d'éventuelles valeurs par défaut. Je ne trouve pas ça terrible...

Oui, sauf que si c'est bien fait, c'est dans la déclaration anticipée, c'est facile à localiser. Il est vrai qu'on peut avoir plusieurs déclarations, mais en général ça se limite à 2 ou 3, pas à 50. Et d'un autre côté c'est le boulot d'un IdE de faire ça (ie t'informer des prototypes).

Et imagines l'inverse, tu veux rajouter des paramètres par défaut, t'es obligé de le faire dans toutes les déclarations, là c'est contraignant ... (même si l'IdE peut t'aider à le faire).

Pour les classes, il ne faudrait le faire qu'à la définition.

D'accord, mais dans ce cas là comment tu fais pour utiliser ton template là où tu n'as besoin que d'une déclaration ? Tu inclus la définition ? Tu payes du temps de compilation supplémentaire pour rien.

Il ne faut pas oublier qu'une déclaration anticipée, ça reste une déclaration. On retrouve la même dualité que celle de déclaration / définition pour les fonctions non template. Et dans ce cas c'est bien la déclaration que tu regardes et non la définition : alors pourquoi quand tu veux voir comment instancier un template tu regarderais la définition et non la déclaration ?

Je suis d'accord que n'avoir les arguments par défaut qu'à un endroit est une contrainte, mais je ne vois pas de solution moins contraignantes.