Petite question philosophique concernant les std::priority_queue.

Soit le code suivant, dans lequel on définit un foncteur qui permet la comparaison entre deux entiers, qui est utilisé dans une std::priority_queue.

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
 
#include <cstdlib>
#include <iostream>
#include <queue>
 
struct Comparator
{
        Comparator(){}
        Comparator(const Comparator & c) { std::cout << "Copy constructor of Comparator\n" ; }
        bool operator()(int a, int b) const { return a<b ; }
} ;
 
int main(int argc, char** argv)
{
        Comparator comp ;
        std::priority_queue<int, std::vector<int>, Comparator> queue(comp) ;
 
        queue.push(3) ; queue.push(5) ; queue.push(4) ; queue.push(6) ; 
 
        while (! queue.empty())
        {
                std::cout << queue.top() << std::endl ;
                queue.pop() ;
        }
 
        return EXIT_SUCCESS ;
}
Si on execute le code, on se rend compte que le constructeur par recopie de Comparator est appelé 26 fois. Je comprends bien qu'en dessous il y a toute la mécanique des appels à make_heap/push_heap/... et que ces fonctions sont appelées 26 fois.

La question que je me pose, cependant, c'est pourquoi le comparateur est copié à chaque appel ?

A noter, en plus, qu'une référence vers instance du comparateur est passé au constructeur de la priority_queue. Au pire, qu'il y ait une copie du comparateur à la construction pour garantir l'existence du comparateur serait tout à fait logique, mais une multitude de copies pour chaque opérations ??

En plus on ne peut pas définir de static operator() .

Je suis conscient que c'est du pinaillage parce que ce n'est pas la mort de recopier une structure sans attribut, mais quand même je trouve que c'est du gâchis. A moins que quelqu'un ait une explication raisonnable qui explique ce choix de conception. Si c'est le cas, je serai plus qu'heureux de l'entendre (je veux dire de la lire).